[getUserMedia] Merge googAutoGainControl and googAutoGainControl2.

Internally, the Audio Processing Module (APM) needs to treat both Auto
Gain Control (AGC) settings as they were one since the implementation does
allow to configure different types of AGCs, but rather a single "best
possible" AGC.

For this reason, this CL merges the two constraints to generate a single
AGC setting. The behavior might break applications only when these two
conditions are meat:
a) both constraints are provided as required, and
b) they contradict each other.

A followup CL will take care of entirely removing the internal property
"goog_experimental_auto_gain_control" when APM does not rely on it any
longer.

Bug: 924485
Change-Id: I280dff85870e0ce8cf557265f22ec98b6cf0acfa
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2041758Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Commit-Queue: Armando Miraglia <armax@chromium.org>
Cr-Commit-Position: refs/heads/master@{#739398}

third_party/blink/renderer/modules/mediastream/media_stream_constraints_util_audio.cc

@@ -152,7 +152,7 @@ class SourceInfo {
 // Container for each independent boolean constrainable property.
 class BooleanContainer {
  public:
-  BooleanContainer(BoolSet allowed_values = BoolSet())
+  explicit BooleanContainer(BoolSet allowed_values = BoolSet())
       : allowed_values_(std::move(allowed_values)) {}
 
   const char* ApplyConstraintSet(const BooleanConstraint& constraint) {
@@ -390,14 +390,15 @@ class EchoCancellationContainer {
         GetDefaultValueForAudioProperties(echo_cancellation_constraint);
 
     properties->goog_auto_gain_control &= default_audio_processing_value;
+    properties->goog_experimental_auto_gain_control &=
+        default_audio_processing_value;
+
     properties->goog_experimental_echo_cancellation &=
         default_audio_processing_value;
     properties->goog_noise_suppression &= default_audio_processing_value;
     properties->goog_experimental_noise_suppression &=
         default_audio_processing_value;
     properties->goog_highpass_filter &= default_audio_processing_value;
-    properties->goog_experimental_auto_gain_control &=
-        default_audio_processing_value;
   }
 
   bool GetDefaultValueForAudioProperties(
@@ -555,6 +556,61 @@ class EchoCancellationContainer {
   bool is_device_capture_;
 };
 
+class AutoGainControlContainer {
+ public:
+  explicit AutoGainControlContainer(BoolSet allowed_values = BoolSet())
+      : allowed_values_(std::move(allowed_values)) {}
+
+  const char* ApplyConstraintSet(const ConstraintSet& constraint_set) {
+    BoolSet agc_set = blink::media_constraints::BoolSetFromConstraint(
+        constraint_set.goog_auto_gain_control);
+    BoolSet experimentaL_agc_set =
+        blink::media_constraints::BoolSetFromConstraint(
+            constraint_set.goog_experimental_auto_gain_control);
+
+    // Apply autoGainControl/googAutoGainControl constraint.
+    allowed_values_ = allowed_values_.Intersection(agc_set);
+    if (IsEmpty())
+      return constraint_set.goog_auto_gain_control.GetName();
+    // Apply also googExperimentalAutoGainControl constraint.
+    allowed_values_ = allowed_values_.Intersection(experimentaL_agc_set);
+
+    return IsEmpty()
+               ? constraint_set.goog_experimental_auto_gain_control.GetName()
+               : nullptr;
+  }
+
+  std::tuple<double, bool> SelectSettingsAndScore(
+      const ConstraintSet& constraint_set,
+      bool default_setting) const {
+    BooleanConstraint agc_constraint = constraint_set.goog_auto_gain_control;
+    BooleanConstraint experimental_agc_constraint =
+        constraint_set.goog_experimental_auto_gain_control;
+
+    if (agc_constraint.HasIdeal() || experimental_agc_constraint.HasIdeal()) {
+      bool agc_ideal =
+          agc_constraint.HasIdeal() ? agc_constraint.Ideal() : false;
+      bool experimentaL_agc_ideal = experimental_agc_constraint.HasIdeal()
+                                        ? experimental_agc_constraint.Ideal()
+                                        : false;
+
+      bool combined_ideal = agc_ideal || experimentaL_agc_ideal;
+      if (allowed_values_.Contains(combined_ideal))
+        return std::make_tuple(1.0, combined_ideal);
+    }
+
+    if (allowed_values_.is_universal())
+      return std::make_tuple(0.0, default_setting);
+
+    return std::make_tuple(0.0, allowed_values_.FirstElement());
+  }
+
+  bool IsEmpty() const { return allowed_values_.IsEmpty(); }
+
+ private:
+  BoolSet allowed_values_;
+};
+
 // This container represents the supported audio settings for a given type of
 // audio source. In practice, there are three types of sources: processed using
 // APM, processed without APM, and unprocessed.
@@ -569,13 +625,12 @@ class ProcessingBasedContainer {
         ProcessingType::kApmProcessed,
         {EchoCancellationType::kEchoCancellationAec3,
          EchoCancellationType::kEchoCancellationDisabled},
+        BoolSet(), /* auto_gain_control_set */
         BoolSet(), /* goog_audio_mirroring_set */
-        BoolSet(), /* goog_auto_gain_control_set */
         BoolSet(), /* goog_experimental_echo_cancellation_set */
         BoolSet(), /* goog_noise_suppression_set */
         BoolSet(), /* goog_experimental_noise_suppression_set */
         BoolSet(), /* goog_highpass_filter_set */
-        BoolSet(), /* goog_experimental_auto_gain_control_set */
         IntRangeSet::FromValue(GetSampleSize()), /* sample_size_range */
         IntRangeSet::FromValue(
             device_parameters.channels()), /* channels_range */
@@ -599,13 +654,12 @@ class ProcessingBasedContainer {
         ProcessingType::kApmProcessed,
         {EchoCancellationType::kEchoCancellationAec3,
          EchoCancellationType::kEchoCancellationDisabled},
+        BoolSet(), /* auto_gain_control_set */
         BoolSet(), /* goog_audio_mirroring_set */
-        BoolSet(), /* goog_auto_gain_control_set */
         BoolSet(), /* goog_experimental_echo_cancellation_set */
         BoolSet(), /* goog_noise_suppression_set */
         BoolSet(), /* goog_experimental_noise_suppression_set */
         BoolSet(), /* goog_highpass_filter_set */
-        BoolSet(), /* goog_experimental_auto_gain_control_set */
         IntRangeSet::FromValue(GetSampleSize()), /* sample_size_range */
         IntRangeSet::FromValue(1),               /* channels_range */
         IntRangeSet::FromValue(
@@ -627,13 +681,12 @@ class ProcessingBasedContainer {
     return ProcessingBasedContainer(
         ProcessingType::kNoApmProcessed,
         {EchoCancellationType::kEchoCancellationDisabled},
+        BoolSet({false}), /* auto_gain_control_set */
         BoolSet(),        /* goog_audio_mirroring_set */
-        BoolSet({false}), /* goog_auto_gain_control_set */
         BoolSet({false}), /* goog_experimental_echo_cancellation_set */
         BoolSet({false}), /* goog_noise_suppression_set */
         BoolSet({false}), /* goog_experimental_noise_suppression_set */
         BoolSet({false}), /* goog_highpass_filter_set */
-        BoolSet({false}), /* goog_experimental_auto_gain_control_set */
         IntRangeSet::FromValue(GetSampleSize()), /* sample_size_range */
         IntRangeSet::FromValue(
             device_parameters.channels()), /* channels_range */
@@ -655,13 +708,12 @@ class ProcessingBasedContainer {
     return ProcessingBasedContainer(
         ProcessingType::kUnprocessed,
         {EchoCancellationType::kEchoCancellationDisabled},
+        BoolSet({false}), /* auto_gain_control_set */
         BoolSet({false}), /* goog_audio_mirroring_set */
-        BoolSet({false}), /* goog_auto_gain_control_set */
         BoolSet({false}), /* goog_experimental_echo_cancellation_set */
         BoolSet({false}), /* goog_noise_suppression_set */
         BoolSet({false}), /* goog_experimental_noise_suppression_set */
         BoolSet({false}), /* goog_highpass_filter_set */
-        BoolSet({false}), /* goog_experimental_auto_gain_control_set */
         IntRangeSet::FromValue(GetSampleSize()), /* sample_size_range */
         IntRangeSet::FromValue(
             device_parameters.channels()), /* channels_range */
@@ -679,6 +731,11 @@ class ProcessingBasedContainer {
     if (failed_constraint_name)
       return failed_constraint_name;
 
+    failed_constraint_name =
+        auto_gain_control_container_.ApplyConstraintSet(constraint_set);
+    if (failed_constraint_name)
+      return failed_constraint_name;
+
     failed_constraint_name =
         sample_size_container_.ApplyConstraintSet(constraint_set.sample_size);
     if (failed_constraint_name)
@@ -767,6 +824,18 @@ class ProcessingBasedContainer {
     echo_cancellation_container_.UpdateDefaultValues(
         constraint_set.echo_cancellation, &properties);
 
+    std::tie(sub_score, properties.goog_auto_gain_control) =
+        auto_gain_control_container_.SelectSettingsAndScore(
+            constraint_set, properties.goog_auto_gain_control);
+    score += sub_score;
+    // Let goog_experimental_auto_gain_control match the value decided for
+    // goog_auto_gain_control.
+    // TODO(crbug.com/924485): entirely remove
+    // goog_experimental_auto_gain_control in the AudioProcessingProperties
+    // object since no longer needed.
+    properties.goog_experimental_auto_gain_control =
+        properties.goog_auto_gain_control;
+
     for (size_t i = 0; i < kNumBooleanContainerIds; ++i) {
       auto& info = kBooleanPropertyContainerInfoMap[i];
       std::tie(sub_score, properties.*(info.property_member)) =
@@ -791,6 +860,7 @@ class ProcessingBasedContainer {
         return true;
     }
     return echo_cancellation_container_.IsEmpty() ||
+           auto_gain_control_container_.IsEmpty() ||
            sample_size_container_.IsEmpty() || channels_container_.IsEmpty() ||
            sample_rate_container_.IsEmpty() || latency_container_.IsEmpty();
   }
@@ -800,12 +870,10 @@ class ProcessingBasedContainer {
  private:
   enum BooleanContainerId {
     kGoogAudioMirroring,
-    kGoogAutoGainControl,
     kGoogExperimentalEchoCancellation,
     kGoogNoiseSuppression,
     kGoogExperimentalNoiseSuppression,
     kGoogHighpassFilter,
-    kGoogExperimentalAutoGainControl,
     kNumBooleanContainerIds
   };
 
@@ -823,8 +891,6 @@ class ProcessingBasedContainer {
       kBooleanPropertyContainerInfoMap[] = {
           {kGoogAudioMirroring, &ConstraintSet::goog_audio_mirroring,
            &AudioProcessingProperties::goog_audio_mirroring},
-          {kGoogAutoGainControl, &ConstraintSet::goog_auto_gain_control,
-           &AudioProcessingProperties::goog_auto_gain_control},
           {kGoogExperimentalEchoCancellation,
            &ConstraintSet::goog_experimental_echo_cancellation,
            &AudioProcessingProperties::goog_experimental_echo_cancellation},
@@ -834,10 +900,7 @@ class ProcessingBasedContainer {
            &ConstraintSet::goog_experimental_noise_suppression,
            &AudioProcessingProperties::goog_experimental_noise_suppression},
           {kGoogHighpassFilter, &ConstraintSet::goog_highpass_filter,
-           &AudioProcessingProperties::goog_highpass_filter},
-          {kGoogExperimentalAutoGainControl,
-           &ConstraintSet::goog_experimental_auto_gain_control,
-           &AudioProcessingProperties::goog_experimental_auto_gain_control}};
+           &AudioProcessingProperties::goog_highpass_filter}};
 
   // Private constructor intended to instantiate different variants of this
   // class based on the initial values provided. The appropriate way to
@@ -848,13 +911,12 @@ class ProcessingBasedContainer {
   ProcessingBasedContainer(
       ProcessingType processing_type,
       std::vector<EchoCancellationType> echo_cancellation_types,
+      BoolSet auto_gain_control_set,
       BoolSet goog_audio_mirroring_set,
-      BoolSet goog_auto_gain_control_set,
       BoolSet goog_experimental_echo_cancellation_set,
       BoolSet goog_noise_suppression_set,
       BoolSet goog_experimental_noise_suppression_set,
       BoolSet goog_highpass_filter_set,
-      BoolSet goog_experimental_auto_gain_control_set,
       IntRangeSet sample_size_range,
       IntRangeSet channels_range,
       IntRangeSet sample_rate_range,
@@ -881,10 +943,11 @@ class ProcessingBasedContainer {
         is_device_capture, device_parameters, source_info.properties(),
         is_reconfiguration_allowed);
 
+    auto_gain_control_container_ =
+        AutoGainControlContainer(auto_gain_control_set);
+
     boolean_containers_[kGoogAudioMirroring] =
         BooleanContainer(goog_audio_mirroring_set);
-    boolean_containers_[kGoogAutoGainControl] =
-        BooleanContainer(goog_auto_gain_control_set);
     boolean_containers_[kGoogExperimentalEchoCancellation] =
         BooleanContainer(goog_experimental_echo_cancellation_set);
     boolean_containers_[kGoogNoiseSuppression] =
@@ -893,12 +956,13 @@ class ProcessingBasedContainer {
         BooleanContainer(goog_experimental_noise_suppression_set);
     boolean_containers_[kGoogHighpassFilter] =
         BooleanContainer(goog_highpass_filter_set);
-    boolean_containers_[kGoogExperimentalAutoGainControl] =
-        BooleanContainer(goog_experimental_auto_gain_control_set);
 
     if (!source_info.HasActiveSource())
       return;
 
+    auto_gain_control_container_ = AutoGainControlContainer(
+        BoolSet({source_info.properties().goog_auto_gain_control}));
+
     for (size_t i = 0; i < kNumBooleanContainerIds; ++i) {
       auto& info = kBooleanPropertyContainerInfoMap[i];
       boolean_containers_[info.index] = BooleanContainer(
@@ -962,6 +1026,7 @@ class ProcessingBasedContainer {
   ProcessingType processing_type_;
   std::array<BooleanContainer, kNumBooleanContainerIds> boolean_containers_;
   EchoCancellationContainer echo_cancellation_container_;
+  AutoGainControlContainer auto_gain_control_container_;
   IntegerContainer sample_size_container_;
   IntegerContainer channels_container_;
   IntegerContainer sample_rate_container_;
@@ -1399,6 +1464,9 @@ AudioCaptureSettings SelectSettingsAudioCapture(
       constraints.Basic(),
       media_stream_source == blink::kMediaStreamSourceDesktop,
       should_disable_hardware_noise_suppression);
+  DCHECK_EQ(settings.audio_processing_properties().goog_auto_gain_control,
+            settings.audio_processing_properties()
+                .goog_experimental_auto_gain_control);
 
   return settings;
 }

third_party/blink/renderer/modules/mediastream/media_stream_constraints_util_audio_test.cc

@@ -213,7 +213,23 @@ class MediaStreamConstraintsUtilAudioTestBase {
     }
     if (!Contains(exclude_audio_properties,
                   &AudioProcessingProperties::goog_auto_gain_control)) {
-      EXPECT_TRUE(properties.goog_auto_gain_control);
+      EXPECT_EQ(properties.goog_auto_gain_control,
+                properties.goog_experimental_auto_gain_control);
+      if (!Contains(exclude_audio_properties,
+                    &AudioProcessingProperties::
+                        goog_experimental_auto_gain_control)) {
+        EXPECT_TRUE(properties.goog_auto_gain_control);
+      }
+    }
+    if (!Contains(
+            exclude_audio_properties,
+            &AudioProcessingProperties::goog_experimental_auto_gain_control)) {
+      EXPECT_EQ(properties.goog_auto_gain_control,
+                properties.goog_experimental_auto_gain_control);
+      if (!Contains(exclude_audio_properties,
+                    &AudioProcessingProperties::goog_auto_gain_control)) {
+        EXPECT_TRUE(properties.goog_experimental_auto_gain_control);
+      }
     }
     if (!Contains(
             exclude_audio_properties,
@@ -233,11 +249,6 @@ class MediaStreamConstraintsUtilAudioTestBase {
                   &AudioProcessingProperties::goog_highpass_filter)) {
       EXPECT_TRUE(properties.goog_highpass_filter);
     }
-    if (!Contains(
-            exclude_audio_properties,
-            &AudioProcessingProperties::goog_experimental_auto_gain_control)) {
-      EXPECT_TRUE(properties.goog_experimental_auto_gain_control);
-    }
   }
 
   void CheckBoolDefaultsContentCapture(
@@ -261,7 +272,23 @@ class MediaStreamConstraintsUtilAudioTestBase {
     }
     if (!Contains(exclude_audio_properties,
                   &AudioProcessingProperties::goog_auto_gain_control)) {
-      EXPECT_FALSE(properties.goog_auto_gain_control);
+      EXPECT_EQ(properties.goog_auto_gain_control,
+                properties.goog_experimental_auto_gain_control);
+      if (!Contains(exclude_audio_properties,
+                    &AudioProcessingProperties::
+                        goog_experimental_auto_gain_control)) {
+        EXPECT_FALSE(properties.goog_auto_gain_control);
+      }
+    }
+    if (!Contains(
+            exclude_audio_properties,
+            &AudioProcessingProperties::goog_experimental_auto_gain_control)) {
+      EXPECT_EQ(properties.goog_auto_gain_control,
+                properties.goog_experimental_auto_gain_control);
+      if (!Contains(exclude_audio_properties,
+                    &AudioProcessingProperties::goog_auto_gain_control)) {
+        EXPECT_FALSE(properties.goog_experimental_auto_gain_control);
+      }
     }
     if (!Contains(
             exclude_audio_properties,
@@ -281,11 +308,6 @@ class MediaStreamConstraintsUtilAudioTestBase {
                   &AudioProcessingProperties::goog_highpass_filter)) {
       EXPECT_FALSE(properties.goog_highpass_filter);
     }
-    if (!Contains(
-            exclude_audio_properties,
-            &AudioProcessingProperties::goog_experimental_auto_gain_control)) {
-      EXPECT_FALSE(properties.goog_experimental_auto_gain_control);
-    }
   }
 
   void CheckBoolDefaults(
@@ -1446,6 +1468,23 @@ TEST_P(MediaStreamConstraintsUtilAudioTest, ContradictoryEchoCancellation) {
   }
 }
 
+// Test that having differing mandatory values for googAutoGainControl and
+// googAutoGainControl2 fails. This test is valid to correctly support the
+// old syntax.
+TEST_P(MediaStreamConstraintsUtilAudioTest, ContradictoryAutoGainControl) {
+  // TODO(armax): fix this.
+  for (bool value : kBoolValues) {
+    constraint_factory_.basic().goog_auto_gain_control.SetExact(value);
+    constraint_factory_.basic().goog_experimental_auto_gain_control.SetExact(
+        !value);
+    auto result = SelectSettings();
+    EXPECT_FALSE(result.HasValue());
+    EXPECT_EQ(result.failed_constraint_name(),
+              constraint_factory_.basic()
+                  .goog_experimental_auto_gain_control.GetName());
+  }
+}
+
 // Tests that individual boolean audio-processing constraints override the
 // default value set by the echoCancellation constraint.
 TEST_P(MediaStreamConstraintsUtilAudioTest,
@@ -1488,6 +1527,15 @@ TEST_P(MediaStreamConstraintsUtilAudioTest,
         for (size_t j = 0; j < kAudioProcessingProperties.size(); ++j) {
           if (i == j)
             continue;
+          // goog_auto_gain_control and goog_experimental_auto_gain_control
+          // should always match in value.
+          if ((i == 1 && j == 6) || (i == 6 && j == 1)) {
+            EXPECT_EQ(result.audio_processing_properties().*
+                          kAudioProcessingProperties[i],
+                      result.audio_processing_properties().*
+                          kAudioProcessingProperties[j]);
+            continue;
+          }
           EXPECT_FALSE(result.audio_processing_properties().*
                        kAudioProcessingProperties[j]);
         }