Support the googNoiseReduction constraint in SelectSettings for video-device capture.

content/renderer/media/media_stream_constraints_util_video_device_unittest.cc

Index: content/renderer/media/media_stream_constraints_util_video_device_unittest.cc
diff --git a/content/renderer/media/media_stream_constraints_util_video_device_unittest.cc b/content/renderer/media/media_stream_constraints_util_video_device_unittest.cc
index 5247f396be50e83bfb11c6fb551560075d9df152..126f06751fc95ce1140cc431bd7e8d95ad6845f7 100644
--- a/content/renderer/media/media_stream_constraints_util_video_device_unittest.cc
+++ b/content/renderer/media/media_stream_constraints_util_video_device_unittest.cc
@@ -100,6 +100,11 @@ class MediaStreamConstraintsUtilVideoDeviceTest : public testing::Test {
         media::PowerLineFrequency::FREQUENCY_60HZ,
     };
 
+    capabilities_.noise_reduction_capabilities = {
+        rtc::Optional<bool>(), rtc::Optional<bool>(true),
+        rtc::Optional<bool>(false),
+    };
+
     default_device_ = capabilities_.device_capabilities[0].get();
     low_res_device_ = capabilities_.device_capabilities[1].get();
     high_res_device_ = capabilities_.device_capabilities[2].get();
@@ -138,6 +143,10 @@ TEST_F(MediaStreamConstraintsUtilVideoDeviceTest, Unconstrained) {
   EXPECT_EQ(default_device_->device_id, result.device_id);
   EXPECT_EQ(default_device_->facing_mode, result.facing_mode);
   EXPECT_EQ(*default_closest_format_, result.Format());
+  // Should select default settings for other constraints.
+  EXPECT_EQ(media::PowerLineFrequency::FREQUENCY_DEFAULT,
+            result.PowerLineFrequency());
+  EXPECT_EQ(rtc::Optional<bool>(), result.noise_reduction);
 }
 
 // The "Overconstrained" tests verify that failure of any single required
@@ -293,6 +302,34 @@ TEST_F(MediaStreamConstraintsUtilVideoDeviceTest,
             result.failed_constraint_name);
 }
 
+TEST_F(MediaStreamConstraintsUtilVideoDeviceTest,
+       OverconstrainedOnNoiseReduction) {
+  // Simulate a system that does not support noise reduction.
+  // Manually adding device capabilities because VideoDeviceCaptureCapabilities
+  // is move only.
+  VideoDeviceCaptureCapabilities capabilities;
+  ::mojom::VideoInputDeviceCapabilitiesPtr device =
+      ::mojom::VideoInputDeviceCapabilities::New();
+  device->device_id = kDeviceID1;
+  device->facing_mode = ::mojom::FacingMode::NONE;
+  device->formats = {
+      media::VideoCaptureFormat(gfx::Size(200, 200), 40.0f,
+                                media::PIXEL_FORMAT_I420),
+  };
+  capabilities.device_capabilities.push_back(std::move(device));
+  capabilities.power_line_capabilities = capabilities_.power_line_capabilities;
+  capabilities.noise_reduction_capabilities = {rtc::Optional<bool>(false)};
+
+  constraint_factory_.Reset();
+  constraint_factory_.basic().googNoiseReduction.setExact(true);
+  auto constraints = constraint_factory_.CreateWebMediaConstraints();
+  auto result =
+      SelectVideoDeviceCaptureSourceSettings(capabilities, constraints);
+  EXPECT_FALSE(result.HasValue());
+  EXPECT_EQ(constraint_factory_.basic().googNoiseReduction.name(),
+            result.failed_constraint_name);
+}
+
 // The "Mandatory" and "Ideal" tests check that various selection criteria work
 // for each individual constraint in the basic constraint set.
 TEST_F(MediaStreamConstraintsUtilVideoDeviceTest, MandatoryDeviceID) {
@@ -385,6 +422,22 @@ TEST_F(MediaStreamConstraintsUtilVideoDeviceTest, MandatoryPowerLineFrequency) {
   }
 }
 
+TEST_F(MediaStreamConstraintsUtilVideoDeviceTest, MandatoryNoiseReduction) {
+  constraint_factory_.Reset();
+  const bool kNoiseReductionValues[] = {true, false};
+  for (auto noise_reduction : kNoiseReductionValues) {
+    constraint_factory_.basic().googNoiseReduction.setExact(noise_reduction);
+    auto result = SelectSettings();
+    EXPECT_TRUE(result.HasValue());
+    EXPECT_EQ(noise_reduction, result.noise_reduction);
+    // The default device and settings closest to the default should be
+    // selected.
+    EXPECT_EQ(default_device_->device_id, result.device_id);
+    EXPECT_EQ(default_device_->facing_mode, result.facing_mode);
+    EXPECT_EQ(*default_closest_format_, result.Format());
+  }
+}
+
 TEST_F(MediaStreamConstraintsUtilVideoDeviceTest, MandatoryExactHeight) {
   constraint_factory_.Reset();
   const int kHeight = MediaStreamVideoSource::kDefaultHeight;
@@ -1288,6 +1341,52 @@ TEST_F(MediaStreamConstraintsUtilVideoDeviceTest,
   }
 }
 
+TEST_F(MediaStreamConstraintsUtilVideoDeviceTest, AdvancedNoiseReduction) {
+  {
+    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);
+    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_TRUE(result.noise_reduction && !*result.noise_reduction);
+  }
+}
+
+TEST_F(MediaStreamConstraintsUtilVideoDeviceTest,
+       AdvancedContradictoryNoiseReduction) {
+  {
+    constraint_factory_.Reset();
+    blink::WebMediaTrackConstraintSet& advanced1 =
+        constraint_factory_.AddAdvanced();
+    advanced1.width.setExact(640);
+    advanced1.height.setExact(480);
+    advanced1.googNoiseReduction.setExact(true);
+    blink::WebMediaTrackConstraintSet& advanced2 =
+        constraint_factory_.AddAdvanced();
+    advanced2.width.setExact(1920);
+    advanced2.height.setExact(1080);
+    advanced2.googNoiseReduction.setExact(false);
+    auto result = SelectSettings();
+    EXPECT_TRUE(result.HasValue());
+    // The second advanced set cannot be satisfied because it contradicts the
+    // first set. The low-res device should be selected in that case.

[hbos_chromium, 2017/02/27 11:57:07]

With Exacts a device will satisfy the first OR the second constraint. It will
reject the second one based not only on the noise reduction being contradictory
but also based on resolution not matching the first one.

This test will be more precise with Minimums, where if it wasn't for the noise
reduction it could actually satisfy both constraints.

Then it will be forced to pick a lower resolution because the higher resolution
cannot be satisfied due to contradiction. If it wasn't for the noise reduction
it would pick the higher resolution because that satisfies both constraints and
not just the first one.

[Guido Urdaneta, 2017/02/27 17:14:21]

Done.

+    EXPECT_EQ(low_res_device_->device_id, result.device_id);
+    EXPECT_EQ(640, result.Width());
+    EXPECT_EQ(480, result.Height());
+    EXPECT_TRUE(result.noise_reduction && *result.noise_reduction);
+  }
+}
+
 // The "NoDevices" tests verify that the algorithm returns the expected result
 // when there are no candidates to choose from.
 TEST_F(MediaStreamConstraintsUtilVideoDeviceTest, NoDevicesNoConstraints) {