Re-land r9378 "Rename APM Config DelayCorrection to ExtendedFilter"

(This reverts commit 3fbf3f8841b5460503fb646eaedcb063620434a8.)

The original submission was reverted because it broke the Chrome build. This is fixed in patch set 2 of this change by keeping the old MediaConstraintsInterface string kExperimentalEchoCancellation. It will be removed once the Chrome code has been updated.

Original description:
"We use this Config struct for enabling/disabling Extended filter mode in AEC. This change renames it to ExtendedFilter for readability reasons. The corresponding media constraint is also renamed to kExtendedFilterEchoCancellation.

The old Config is kept in parallel with the new during a transition period. This is to avoid problems with API breakages. During this period, if any of the two Configs are enabled, the extended filter mode is engaged in APM. That is, the two Configs are combined with an "OR" operation.

This change also renames experimental_aec in AudioOptions to extended_filter_aec."

BUG=webrtc:4696
R=bjornv@webrtc.org, tommi@webrtc.org

Review URL: https://codereview.webrtc.org/1151573021.

Cr-Commit-Position: refs/heads/master@{#9401}

talk/app/webrtc/localaudiosource.cc

@@ -43,43 +43,51 @@ namespace {
 // invalid.
 void FromConstraints(const MediaConstraintsInterface::Constraints& constraints,
                      cricket::AudioOptions* options) {
-  MediaConstraintsInterface::Constraints::const_iterator iter;
-
   // This design relies on the fact that all the audio constraints are actually
   // "options", i.e. boolean-valued and always satisfiable.  If the constraints
   // are extended to include non-boolean values or actual format constraints,
   // a different algorithm will be required.
-  for (iter = constraints.begin(); iter != constraints.end(); ++iter) {
-    bool value = false;
+  struct {
+    const char* name;
+    cricket::Settable<bool>& value;
+  } key_to_value[] = {
+      {MediaConstraintsInterface::kEchoCancellation,
+       options->echo_cancellation},
+      // Both kExperimentalEchoCancellation (old) and
+      // kExtendedFilterEchoCancellation (new) translate to
+      // extended_filter_aec
+      // option being set. This is to manage the transition from the old to
+      // the
+      // new without breaking dependent code.
+      {MediaConstraintsInterface::kExperimentalEchoCancellation,
+       options->extended_filter_aec},
+      {MediaConstraintsInterface::kExtendedFilterEchoCancellation,
+       options->extended_filter_aec},
+      {MediaConstraintsInterface::kDAEchoCancellation,
+       options->delay_agnostic_aec},
+      {MediaConstraintsInterface::kAutoGainControl, options->auto_gain_control},
+      {MediaConstraintsInterface::kExperimentalAutoGainControl,
+       options->experimental_agc},
+      {MediaConstraintsInterface::kNoiseSuppression,
+       options->noise_suppression},
+      {MediaConstraintsInterface::kExperimentalNoiseSuppression,
+       options->experimental_ns},
+      {MediaConstraintsInterface::kHighpassFilter, options->highpass_filter},
+      {MediaConstraintsInterface::kTypingNoiseDetection,
+       options->typing_detection},
+      {MediaConstraintsInterface::kAudioMirroring, options->stereo_swapping},
+      {MediaConstraintsInterface::kAecDump, options->aec_dump}
+  };
 
-    if (!rtc::FromString(iter->value, &value))
+  for (const auto& constraint : constraints) {
+    bool value = false;
+    if (!rtc::FromString(constraint.value, &value))
       continue;
 
-    if (iter->key == MediaConstraintsInterface::kEchoCancellation)
-      options->echo_cancellation.Set(value);
-    else if (iter->key ==
-        MediaConstraintsInterface::kExperimentalEchoCancellation)
-      options->experimental_aec.Set(value);
-    else if (iter->key == MediaConstraintsInterface::kDAEchoCancellation)
-      options->delay_agnostic_aec.Set(value);
-    else if (iter->key == MediaConstraintsInterface::kAutoGainControl)
-      options->auto_gain_control.Set(value);
-    else if (iter->key ==
-        MediaConstraintsInterface::kExperimentalAutoGainControl)
-      options->experimental_agc.Set(value);
-    else if (iter->key == MediaConstraintsInterface::kNoiseSuppression)
-      options->noise_suppression.Set(value);
-    else if (iter->key ==
-          MediaConstraintsInterface::kExperimentalNoiseSuppression)
-      options->experimental_ns.Set(value);
-    else if (iter->key == MediaConstraintsInterface::kHighpassFilter)
-      options->highpass_filter.Set(value);
-    else if (iter->key == MediaConstraintsInterface::kTypingNoiseDetection)
-      options->typing_detection.Set(value);
-    else if (iter->key == MediaConstraintsInterface::kAudioMirroring)
-      options->stereo_swapping.Set(value);
-    else if (iter->key == MediaConstraintsInterface::kAecDump)
-      options->aec_dump.Set(value);
+    for (auto& entry : key_to_value) {
+      if (constraint.key.compare(entry.name) == 0)
+        entry.value.Set(value);
+    }
   }
 }
 

talk/app/webrtc/localaudiosource_unittest.cc

@@ -45,7 +45,7 @@ TEST(LocalAudioSourceTest, SetValidOptions) {
   webrtc::FakeConstraints constraints;
   constraints.AddMandatory(MediaConstraintsInterface::kEchoCancellation, false);
   constraints.AddOptional(
-      MediaConstraintsInterface::kExperimentalEchoCancellation, true);
+      MediaConstraintsInterface::kExtendedFilterEchoCancellation, true);
   constraints.AddOptional(MediaConstraintsInterface::kDAEchoCancellation, true);
   constraints.AddOptional(MediaConstraintsInterface::kAutoGainControl, true);
   constraints.AddOptional(
@@ -61,7 +61,7 @@ TEST(LocalAudioSourceTest, SetValidOptions) {
   bool value;
   EXPECT_TRUE(source->options().echo_cancellation.Get(&value));
   EXPECT_FALSE(value);
-  EXPECT_TRUE(source->options().experimental_aec.Get(&value));
+  EXPECT_TRUE(source->options().extended_filter_aec.Get(&value));
   EXPECT_TRUE(value);
   EXPECT_TRUE(source->options().delay_agnostic_aec.Get(&value));
   EXPECT_TRUE(value);
@@ -77,6 +77,51 @@ TEST(LocalAudioSourceTest, SetValidOptions) {
   EXPECT_TRUE(value);
 }
 
+// TODO(henrik.lundin) Remove SetExtendedFilterEchoCancellationOff test.
+// https://code.google.com/p/webrtc/issues/detail?id=4696
+TEST(LocalAudioSourceTest, SetExtendedFilterEchoCancellationOff) {
+  webrtc::FakeConstraints constraints;
+  constraints.AddOptional(
+      MediaConstraintsInterface::kExtendedFilterEchoCancellation, false);
+
+  rtc::scoped_refptr<LocalAudioSource> source = LocalAudioSource::Create(
+      PeerConnectionFactoryInterface::Options(), &constraints);
+
+  bool value;
+  EXPECT_TRUE(source->options().extended_filter_aec.Get(&value));
+  EXPECT_FALSE(value);
+}
+
+// TODO(henrik.lundin) Remove SetExperimentalEchoCancellationOn test.
+// https://code.google.com/p/webrtc/issues/detail?id=4696
+TEST(LocalAudioSourceTest, SetExperimentalEchoCancellationOn) {
+  webrtc::FakeConstraints constraints;
+  constraints.AddOptional(
+      MediaConstraintsInterface::kExperimentalEchoCancellation, true);
+
+  rtc::scoped_refptr<LocalAudioSource> source = LocalAudioSource::Create(
+      PeerConnectionFactoryInterface::Options(), &constraints);
+
+  bool value;
+  EXPECT_TRUE(source->options().extended_filter_aec.Get(&value));
+  EXPECT_TRUE(value);
+}
+
+// TODO(henrik.lundin) Remove SetExperimentalEchoCancellationOff test.
+// https://code.google.com/p/webrtc/issues/detail?id=4696
+TEST(LocalAudioSourceTest, SetExperimentalEchoCancellationOff) {
+  webrtc::FakeConstraints constraints;
+  constraints.AddOptional(
+      MediaConstraintsInterface::kExperimentalEchoCancellation, false);
+
+  rtc::scoped_refptr<LocalAudioSource> source = LocalAudioSource::Create(
+      PeerConnectionFactoryInterface::Options(), &constraints);
+
+  bool value;
+  EXPECT_TRUE(source->options().extended_filter_aec.Get(&value));
+  EXPECT_FALSE(value);
+}
+
 TEST(LocalAudioSourceTest, OptionNotSet) {
   webrtc::FakeConstraints constraints;
   rtc::scoped_refptr<LocalAudioSource> source =

talk/app/webrtc/mediaconstraintsinterface.cc

@@ -50,6 +50,8 @@ const char MediaConstraintsInterface::kEchoCancellation[] =
     "googEchoCancellation";
 const char MediaConstraintsInterface::kExperimentalEchoCancellation[] =
     "googEchoCancellation2";
+const char MediaConstraintsInterface::kExtendedFilterEchoCancellation[] =
+    "googEchoCancellation2";
 const char MediaConstraintsInterface::kDAEchoCancellation[] =
     "googDAEchoCancellation";
 const char MediaConstraintsInterface::kAutoGainControl[] =

talk/app/webrtc/mediaconstraintsinterface.h

@@ -74,7 +74,10 @@ class MediaConstraintsInterface {
   // Constraint keys used by a local audio source.
   // These keys are google specific.
   static const char kEchoCancellation[];  // googEchoCancellation
+  // TODO(henrik.lundin) Remove kExperimentalEchoCancellation.
+  // https://code.google.com/p/webrtc/issues/detail?id=4696
   static const char kExperimentalEchoCancellation[];  // googEchoCancellation2
+  static const char kExtendedFilterEchoCancellation[];  // googEchoCancellation2
   static const char kDAEchoCancellation[];  // googDAEchoCancellation
   static const char kAutoGainControl[];  // googAutoGainControl
   static const char kExperimentalAutoGainControl[];  // googAutoGainControl2

talk/media/base/mediachannel.h

@@ -159,7 +159,7 @@ struct AudioOptions {
     conference_mode.SetFrom(change.conference_mode);
     adjust_agc_delta.SetFrom(change.adjust_agc_delta);
     experimental_agc.SetFrom(change.experimental_agc);
-    experimental_aec.SetFrom(change.experimental_aec);
+    extended_filter_aec.SetFrom(change.extended_filter_aec);
     delay_agnostic_aec.SetFrom(change.delay_agnostic_aec);
     experimental_ns.SetFrom(change.experimental_ns);
     aec_dump.SetFrom(change.aec_dump);
@@ -191,7 +191,7 @@ struct AudioOptions {
         aecm_generate_comfort_noise == o.aecm_generate_comfort_noise &&
         conference_mode == o.conference_mode &&
         experimental_agc == o.experimental_agc &&
-        experimental_aec == o.experimental_aec &&
+        extended_filter_aec == o.extended_filter_aec &&
         delay_agnostic_aec == o.delay_agnostic_aec &&
         experimental_ns == o.experimental_ns &&
         adjust_agc_delta == o.adjust_agc_delta &&
@@ -226,7 +226,7 @@ struct AudioOptions {
     ost << ToStringIfSet("conference", conference_mode);
     ost << ToStringIfSet("agc_delta", adjust_agc_delta);
     ost << ToStringIfSet("experimental_agc", experimental_agc);
-    ost << ToStringIfSet("experimental_aec", experimental_aec);
+    ost << ToStringIfSet("extended_filter_aec", extended_filter_aec);
     ost << ToStringIfSet("delay_agnostic_aec", delay_agnostic_aec);
     ost << ToStringIfSet("experimental_ns", experimental_ns);
     ost << ToStringIfSet("aec_dump", aec_dump);
@@ -269,7 +269,7 @@ struct AudioOptions {
   Settable<bool> conference_mode;
   Settable<int> adjust_agc_delta;
   Settable<bool> experimental_agc;
-  Settable<bool> experimental_aec;
+  Settable<bool> extended_filter_aec;
   Settable<bool> delay_agnostic_aec;
   Settable<bool> experimental_ns;
   Settable<bool> aec_dump;

talk/media/webrtc/webrtcvoiceengine.cc

@@ -357,7 +357,7 @@ static AudioOptions GetDefaultEngineOptions() {
   options.conference_mode.Set(false);
   options.adjust_agc_delta.Set(0);
   options.experimental_agc.Set(false);
-  options.experimental_aec.Set(false);
+  options.extended_filter_aec.Set(false);
   options.delay_agnostic_aec.Set(false);
   options.experimental_ns.Set(false);
   options.aec_dump.Set(false);
@@ -661,7 +661,7 @@ bool WebRtcVoiceEngine::ApplyOptions(const AudioOptions& options_in) {
   agc_mode = webrtc::kAgcFixedDigital;
   options.typing_detection.Set(false);
   options.experimental_agc.Set(false);
-  options.experimental_aec.Set(false);
+  options.extended_filter_aec.Set(false);
   options.experimental_ns.Set(false);
 #endif
 
@@ -672,7 +672,7 @@ bool WebRtcVoiceEngine::ApplyOptions(const AudioOptions& options_in) {
   if (options.delay_agnostic_aec.Get(&use_delay_agnostic_aec)) {
     if (use_delay_agnostic_aec) {
       options.echo_cancellation.Set(true);
-      options.experimental_aec.Set(true);
+      options.extended_filter_aec.Set(true);
       ec_mode = webrtc::kEcConference;
     }
   }
@@ -848,12 +848,12 @@ bool WebRtcVoiceEngine::ApplyOptions(const AudioOptions& options_in) {
         new webrtc::ReportedDelay(!delay_agnostic_aec));
   }
 
-  experimental_aec_.SetFrom(options.experimental_aec);
-  bool experimental_aec;
-  if (experimental_aec_.Get(&experimental_aec)) {
-    LOG(LS_INFO) << "Experimental aec is enabled? " << experimental_aec;
-    config.Set<webrtc::DelayCorrection>(
-        new webrtc::DelayCorrection(experimental_aec));
+  extended_filter_aec_.SetFrom(options.extended_filter_aec);
+  bool extended_filter;
+  if (extended_filter_aec_.Get(&extended_filter)) {
+    LOG(LS_INFO) << "Extended filter aec is enabled? " << extended_filter;
+    config.Set<webrtc::ExtendedFilter>(
+        new webrtc::ExtendedFilter(extended_filter));
   }
 
   experimental_ns_.SetFrom(options.experimental_ns);

talk/media/webrtc/webrtcvoiceengine.h

@@ -266,11 +266,11 @@ class WebRtcVoiceEngine
 
   rtc::CriticalSection signal_media_critical_;
 
-  // Cache received experimental_aec, delay_agnostic_aec and experimental_ns
+  // Cache received extended_filter_aec, delay_agnostic_aec and experimental_ns
   // values, and apply them in case they are missing in the audio options. We
   // need to do this because SetExtraOptions() will revert to defaults for
   // options which are not provided.
-  Settable<bool> experimental_aec_;
+  Settable<bool> extended_filter_aec_;
   Settable<bool> delay_agnostic_aec_;
   Settable<bool> experimental_ns_;
 };

talk/media/webrtc/webrtcvoiceengine_unittest.cc

@@ -2895,7 +2895,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetAudioOptions) {
 
   // Turn off echo cancellation and delay agnostic aec.
   options.delay_agnostic_aec.Set(false);
-  options.experimental_aec.Set(false);
+  options.extended_filter_aec.Set(false);
   options.echo_cancellation.Set(false);
   ASSERT_TRUE(engine_.SetOptions(options));
   voe_.GetEcStatus(ec_enabled, ec_mode);

webrtc/modules/audio_processing/aec/aec_core.c

@@ -1934,14 +1934,14 @@ int WebRtcAec_reported_delay_enabled(AecCore* self) {
   return self->reported_delay_enabled;
 }
 
-void WebRtcAec_enable_delay_correction(AecCore* self, int enable) {
+void WebRtcAec_enable_extended_filter(AecCore* self, int enable) {
   self->extended_filter_enabled = enable;
   self->num_partitions = enable ? kExtendedNumPartitions : kNormalNumPartitions;
   // Update the delay estimator with filter length.  See InitAEC() for details.
   WebRtc_set_allowed_offset(self->delay_estimator, self->num_partitions / 2);
 }
 
-int WebRtcAec_delay_correction_enabled(AecCore* self) {
+int WebRtcAec_extended_filter_enabled(AecCore* self) {
   return self->extended_filter_enabled;
 }
 

webrtc/modules/audio_processing/aec/aec_core.h

@@ -108,14 +108,11 @@ void WebRtcAec_enable_reported_delay(AecCore* self, int enable);
 // Returns non-zero if reported delay is enabled and zero if disabled.
 int WebRtcAec_reported_delay_enabled(AecCore* self);
 
-// We now interpret delay correction to mean an extended filter length feature.
-// We reuse the delay correction infrastructure to avoid changes through to
-// libjingle. See details along with |DelayCorrection| in
-// echo_cancellation_impl.h. Non-zero enables, zero disables.
-void WebRtcAec_enable_delay_correction(AecCore* self, int enable);
+// Enables or disables extended filter mode. Non-zero enables, zero disables.
+void WebRtcAec_enable_extended_filter(AecCore* self, int enable);
 
-// Returns non-zero if delay correction is enabled and zero if disabled.
-int WebRtcAec_delay_correction_enabled(AecCore* self);
+// Returns non-zero if extended filter mode is enabled and zero if disabled.
+int WebRtcAec_extended_filter_enabled(AecCore* self);
 
 // Returns the current |system_delay|, i.e., the buffered difference between
 // far-end and near-end.

webrtc/modules/audio_processing/aec/echo_cancellation.c

@@ -373,7 +373,7 @@ int32_t WebRtcAec_Process(void* aecInst,
   }
 
   // This returns the value of aec->extended_filter_enabled.
-  if (WebRtcAec_delay_correction_enabled(aecpc->aec)) {
+  if (WebRtcAec_extended_filter_enabled(aecpc->aec)) {
     ProcessExtended(aecpc,
                     nearend,
                     num_bands,

webrtc/modules/audio_processing/echo_cancellation_impl.cc

@@ -57,18 +57,19 @@ AudioProcessing::Error MapError(int err) {
 
 EchoCancellationImpl::EchoCancellationImpl(const AudioProcessing* apm,
                                            CriticalSectionWrapper* crit)
-  : ProcessingComponent(),
-    apm_(apm),
-    crit_(crit),
-    drift_compensation_enabled_(false),
-    metrics_enabled_(false),
-    suppression_level_(kModerateSuppression),
-    stream_drift_samples_(0),
-    was_stream_drift_set_(false),
-    stream_has_echo_(false),
-    delay_logging_enabled_(false),
-    delay_correction_enabled_(false),
-    reported_delay_enabled_(true) {}
+    : ProcessingComponent(),
+      apm_(apm),
+      crit_(crit),
+      drift_compensation_enabled_(false),
+      metrics_enabled_(false),
+      suppression_level_(kModerateSuppression),
+      stream_drift_samples_(0),
+      was_stream_drift_set_(false),
+      stream_has_echo_(false),
+      delay_logging_enabled_(false),
+      extended_filter_enabled_(false),
+      reported_delay_enabled_(true) {
+}
 
 EchoCancellationImpl::~EchoCancellationImpl() {}
 
@@ -327,7 +328,10 @@ int EchoCancellationImpl::Initialize() {
 }
 
 void EchoCancellationImpl::SetExtraOptions(const Config& config) {
-  delay_correction_enabled_ = config.Get<DelayCorrection>().enabled;
+  // Both ExtendedFilter and DelayCorrection are diabled by default. If any one
+  // of them is true, then the extended filter mode is enabled.
+  extended_filter_enabled_ = config.Get<ExtendedFilter>().enabled ||
+                             config.Get<DelayCorrection>().enabled;
   reported_delay_enabled_ = config.Get<ReportedDelay>().enabled;
   Configure();
 }
@@ -366,8 +370,9 @@ int EchoCancellationImpl::ConfigureHandle(void* handle) const {
   config.skewMode = drift_compensation_enabled_;
   config.delay_logging = delay_logging_enabled_;
 
-  WebRtcAec_enable_delay_correction(WebRtcAec_aec_core(
-      static_cast<Handle*>(handle)), delay_correction_enabled_ ? 1 : 0);
+  WebRtcAec_enable_extended_filter(
+      WebRtcAec_aec_core(static_cast<Handle*>(handle)),
+      extended_filter_enabled_ ? 1 : 0);
   WebRtcAec_enable_reported_delay(WebRtcAec_aec_core(
       static_cast<Handle*>(handle)), reported_delay_enabled_ ? 1 : 0);
   return WebRtcAec_set_config(static_cast<Handle*>(handle), config);

webrtc/modules/audio_processing/echo_cancellation_impl.h

@@ -74,7 +74,7 @@ class EchoCancellationImpl : public EchoCancellation,
   bool was_stream_drift_set_;
   bool stream_has_echo_;
   bool delay_logging_enabled_;
-  bool delay_correction_enabled_;
+  bool extended_filter_enabled_;
   bool reported_delay_enabled_;
 };
 

webrtc/modules/audio_processing/echo_cancellation_impl_unittest.cc

@@ -18,7 +18,7 @@ extern "C" {
 
 namespace webrtc {
 
-TEST(EchoCancellationInternalTest, DelayCorrection) {
+TEST(EchoCancellationInternalTest, ExtendedFilter) {
   rtc::scoped_ptr<AudioProcessing> ap(AudioProcessing::Create());
   EXPECT_TRUE(ap->echo_cancellation()->aec_core() == NULL);
 
@@ -28,24 +28,24 @@ TEST(EchoCancellationInternalTest, DelayCorrection) {
   AecCore* aec_core = ap->echo_cancellation()->aec_core();
   ASSERT_TRUE(aec_core != NULL);
   // Disabled by default.
-  EXPECT_EQ(0, WebRtcAec_delay_correction_enabled(aec_core));
+  EXPECT_EQ(0, WebRtcAec_extended_filter_enabled(aec_core));
 
   Config config;
-  config.Set<DelayCorrection>(new DelayCorrection(true));
+  config.Set<ExtendedFilter>(new ExtendedFilter(true));
   ap->SetExtraOptions(config);
-  EXPECT_EQ(1, WebRtcAec_delay_correction_enabled(aec_core));
+  EXPECT_EQ(1, WebRtcAec_extended_filter_enabled(aec_core));
 
   // Retains setting after initialization.
   EXPECT_EQ(ap->kNoError, ap->Initialize());
-  EXPECT_EQ(1, WebRtcAec_delay_correction_enabled(aec_core));
+  EXPECT_EQ(1, WebRtcAec_extended_filter_enabled(aec_core));
 
-  config.Set<DelayCorrection>(new DelayCorrection(false));
+  config.Set<ExtendedFilter>(new ExtendedFilter(false));
   ap->SetExtraOptions(config);
-  EXPECT_EQ(0, WebRtcAec_delay_correction_enabled(aec_core));
+  EXPECT_EQ(0, WebRtcAec_extended_filter_enabled(aec_core));
 
   // Retains setting after initialization.
   EXPECT_EQ(ap->kNoError, ap->Initialize());
-  EXPECT_EQ(0, WebRtcAec_delay_correction_enabled(aec_core));
+  EXPECT_EQ(0, WebRtcAec_extended_filter_enabled(aec_core));
 }
 
 TEST(EchoCancellationInternalTest, ReportedDelay) {

webrtc/modules/audio_processing/include/audio_processing.h

@@ -37,10 +37,10 @@ class LevelEstimator;
 class NoiseSuppression;
 class VoiceDetection;
 
-// Use to enable the delay correction feature. This now engages an extended
-// filter mode in the AEC, along with robustness measures around the reported
-// system delays. It comes with a significant increase in AEC complexity, but is
-// much more robust to unreliable reported delays.
+// Use to enable the extended filter mode in the AEC, along with robustness
+// measures around the reported system delays. It comes with a significant
+// increase in AEC complexity, but is much more robust to unreliable reported
+// delays.
 //
 // Detailed changes to the algorithm:
 // - The filter length is changed from 48 to 128 ms. This comes with tuning of
@@ -54,11 +54,19 @@ class VoiceDetection;
 //   the delay difference more heavily, and back off from the difference more.
 //   Adjustments force a readaptation of the filter, so they should be avoided
 //   except when really necessary.
+// TODO(henrik.lundin): Remove DelayCorrection once ExtendedFilter has
+// propagated through to all channels
+// (https://code.google.com/p/webrtc/issues/detail?id=4696).
 struct DelayCorrection {
   DelayCorrection() : enabled(false) {}
   explicit DelayCorrection(bool enabled) : enabled(enabled) {}
   bool enabled;
 };
+struct ExtendedFilter {
+  ExtendedFilter() : enabled(false) {}
+  explicit ExtendedFilter(bool enabled) : enabled(enabled) {}
+  bool enabled;
+};
 
 // Use to disable the reported system delays. By disabling the reported system
 // delays the echo cancellation algorithm assumes the process and reverse

webrtc/modules/audio_processing/test/audio_processing_unittest.cc

@@ -1587,7 +1587,7 @@ TEST_F(ApmTest, SplittingFilter) {
   // Make sure we have extended filter enabled. This makes sure nothing is
   // touched until we have a farend frame.
   Config config;
-  config.Set<DelayCorrection>(new DelayCorrection(true));
+  config.Set<ExtendedFilter>(new ExtendedFilter(true));
   apm_->SetExtraOptions(config);
   SetFrameTo(frame_, 1000);
   frame_copy.CopyFrom(*frame_);
@@ -1969,8 +1969,8 @@ TEST_F(ApmTest, Process) {
 
     Config config;
     config.Set<ExperimentalAgc>(new ExperimentalAgc(false));
-    config.Set<DelayCorrection>(
-        new DelayCorrection(test->use_aec_extended_filter()));
+    config.Set<ExtendedFilter>(
+        new ExtendedFilter(test->use_aec_extended_filter()));
     apm_.reset(AudioProcessing::Create(config));
 
     EnableAllComponents();

webrtc/modules/audio_processing/test/process_test.cc

@@ -258,7 +258,7 @@ void void_main(int argc, char* argv[]) {
                         suppression_level)));
 
     } else if (strcmp(argv[i], "--extended_filter") == 0) {
-      config.Set<DelayCorrection>(new DelayCorrection(true));
+      config.Set<ExtendedFilter>(new ExtendedFilter(true));
 
     } else if (strcmp(argv[i], "--no_reported_delay") == 0) {
       config.Set<ReportedDelay>(new ReportedDelay(false));