Enable new getUserMedia audio constraints algorithm behind a flag.

content/renderer/media/media_stream_audio_processor_unittest.cc

 // Copyright 2013 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 <stddef.h>
 #include <stdint.h>
 
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/aligned_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
+#include "base/test/scoped_feature_list.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "content/common/media/media_stream_options.h"
+#include "content/public/common/content_features.h"
 #include "content/public/common/media_stream_request.h"
 #include "content/renderer/media/media_stream_audio_processor.h"
 #include "content/renderer/media/media_stream_audio_processor_options.h"
 #include "content/renderer/media/mock_constraint_factory.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_parameters.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/webrtc/api/mediastreaminterface.h"
@@ skipping 36 matching lines @@
              .Append(FILE_PATH_LITERAL("test"))
              .Append(FILE_PATH_LITERAL("data"))
              .Append(FILE_PATH_LITERAL("speech_16b_stereo_48kHz.raw"));
   DCHECK(base::PathExists(file));
   int64_t data_file_size64 = 0;
   DCHECK(base::GetFileSize(file, &data_file_size64));
   EXPECT_EQ(length, base::ReadFile(file, data, length));
   DCHECK(data_file_size64 > length);
 }
 
+void DisableDefaultAudioProcessingProperties(
+    AudioProcessingProperties* properties) {
+  properties->enable_sw_echo_cancellation = false;
+  properties->goog_experimental_echo_cancellation = false;
+  properties->goog_auto_gain_control = false;
+  properties->goog_experimental_auto_gain_control = false;
+  properties->goog_noise_suppression = false;
+  properties->goog_noise_suppression = false;

[hbos_chromium, 2017/06/16 17:27:14]

nit: disabled twice

[Guido Urdaneta, 2017/06/19 11:56:48]

Fixed.

+  properties->goog_highpass_filter = false;
+  properties->goog_typing_noise_detection = false;
+  properties->goog_experimental_noise_suppression = false;
+  properties->goog_beamforming = false;
+}
+
 }  // namespace
 
 class MediaStreamAudioProcessorTest : public ::testing::Test {
  public:
   MediaStreamAudioProcessorTest()
       : params_(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
                 media::CHANNEL_LAYOUT_STEREO, 48000, 16, 512) {
+    // This file includes tests for MediaStreamAudioProcessor, but also for
+    // the old constraints algorithm. The MediaStreamAudioProcessor tests are
+    // insensitive to the constraints algorithm, but the constraints tests
+    // require that the old constraints algorithm be enabled.
+    scoped_feature_list_.InitAndEnableFeature(
+        features::kMediaStreamOldAudioConstraints);
   }
 
  protected:
   // Helper method to save duplicated code.
   void ProcessDataAndVerifyFormat(MediaStreamAudioProcessor* audio_processor,
                                   int expected_output_sample_rate,
                                   int expected_output_channels,
                                   int expected_output_buffer_size) {
     // Read the audio data from a file.
     const media::AudioParameters& params = audio_processor->InputFormat();
@@ skipping 111 matching lines @@
       ADD_FAILURE() << "AudioProcessing object missing where it shouldn't be";
       return false;
     }
     return audio_processor->audio_processing_->GetConfig()
         .echo_canceller3.enabled;
   }
 
   base::MessageLoop main_thread_message_loop_;
   media::AudioParameters params_;
   MediaStreamDevice::AudioDeviceParameters input_device_params_;
+
+  // TODO(guidou): Remove this field. http://crbug.com/706408
+  base::test::ScopedFeatureList scoped_feature_list_;
 };
 
 // Test crashing with ASAN on Android. crbug.com/468762
 #if defined(OS_ANDROID) && defined(ADDRESS_SANITIZER)
 #define MAYBE_WithAudioProcessing DISABLED_WithAudioProcessing
 #else
 #define MAYBE_WithAudioProcessing WithAudioProcessing
 #endif
 TEST_F(MediaStreamAudioProcessorTest, MAYBE_WithAudioProcessing) {
-  MockConstraintFactory constraint_factory;
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
+  AudioProcessingProperties properties;
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new rtc::RefCountedObject<MediaStreamAudioProcessor>(
-          constraint_factory.CreateWebMediaConstraints(), input_device_params_,
-          webrtc_audio_device.get()));
+          properties, webrtc_audio_device.get()));
   EXPECT_TRUE(audio_processor->has_audio_processing());
   audio_processor->OnCaptureFormatChanged(params_);
   VerifyDefaultComponents(audio_processor.get());
 
   ProcessDataAndVerifyFormat(audio_processor.get(),
                              kAudioProcessingSampleRate,
                              kAudioProcessingNumberOfChannel,
                              kAudioProcessingSampleRate / 100);
 
   // Stop |audio_processor| so that it removes itself from
   // |webrtc_audio_device| and clears its pointer to it.
   audio_processor->Stop();
 }
 
-TEST_F(MediaStreamAudioProcessorTest, VerifyTabCaptureWithoutAudioProcessing) {
-  scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
-      new WebRtcAudioDeviceImpl());
-  // Create MediaStreamAudioProcessor instance for kMediaStreamSourceTab source.
-  MockConstraintFactory tab_constraint_factory;
-  const std::string tab_string = kMediaStreamSourceTab;
-  tab_constraint_factory.basic().media_stream_source.SetExact(
-      blink::WebString::FromUTF8(tab_string));
-  scoped_refptr<MediaStreamAudioProcessor> audio_processor(
-      new rtc::RefCountedObject<MediaStreamAudioProcessor>(
-          tab_constraint_factory.CreateWebMediaConstraints(),
-          input_device_params_, webrtc_audio_device.get()));
-  EXPECT_FALSE(audio_processor->has_audio_processing());
-  audio_processor->OnCaptureFormatChanged(params_);
-
-  ProcessDataAndVerifyFormat(audio_processor.get(),
-                             params_.sample_rate(),
-                             params_.channels(),
-                             params_.sample_rate() / 100);
-
-  // Create MediaStreamAudioProcessor instance for kMediaStreamSourceSystem
-  // source.
-  MockConstraintFactory system_constraint_factory;
-  const std::string system_string = kMediaStreamSourceSystem;
-  system_constraint_factory.basic().media_stream_source.SetExact(
-      blink::WebString::FromUTF8(system_string));
-  audio_processor = new rtc::RefCountedObject<MediaStreamAudioProcessor>(
-      system_constraint_factory.CreateWebMediaConstraints(),
-      input_device_params_, webrtc_audio_device.get());
-  EXPECT_FALSE(audio_processor->has_audio_processing());
-
-  // Stop |audio_processor| so that it removes itself from
-  // |webrtc_audio_device| and clears its pointer to it.
-  audio_processor->Stop();
-}
-
 TEST_F(MediaStreamAudioProcessorTest, TurnOffDefaultConstraints) {
+  AudioProcessingProperties properties;
   // Turn off the default constraints and pass it to MediaStreamAudioProcessor.
-  MockConstraintFactory constraint_factory;
-  constraint_factory.DisableDefaultAudioConstraints();
+  DisableDefaultAudioProcessingProperties(&properties);
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new rtc::RefCountedObject<MediaStreamAudioProcessor>(
-          constraint_factory.CreateWebMediaConstraints(), input_device_params_,
-          webrtc_audio_device.get()));
+          properties, webrtc_audio_device.get()));
   EXPECT_FALSE(audio_processor->has_audio_processing());
   audio_processor->OnCaptureFormatChanged(params_);
 
   ProcessDataAndVerifyFormat(audio_processor.get(),
                              params_.sample_rate(),
                              params_.channels(),
                              params_.sample_rate() / 100);
 
   // Stop |audio_processor| so that it removes itself from
   // |webrtc_audio_device| and clears its pointer to it.
   audio_processor->Stop();
 }
 
+// TODO(guidou): Remove this test. http://crbug.com/706408
 TEST_F(MediaStreamAudioProcessorTest, VerifyConstraints) {
   {
     // Verify that echo cancellation is off when platform aec effect is on.
     MockConstraintFactory constraint_factory;
     MediaAudioConstraints audio_constraints(
         constraint_factory.CreateWebMediaConstraints(),
         media::AudioParameters::ECHO_CANCELLER);
     EXPECT_FALSE(audio_constraints.GetEchoCancellationProperty());
   }
 
@@ skipping 19 matching lines @@
     // When |kEchoCancellation| is explicitly set to false, the default values
     // for all the constraints are false.
     MockConstraintFactory constraint_factory;
     constraint_factory.AddAdvanced().echo_cancellation.SetExact(false);
     blink::WebMediaConstraints constraints =
         constraint_factory.CreateWebMediaConstraints();
     MediaAudioConstraints audio_constraints(constraints, 0);
   }
 }
 
+// TODO(guidou): Remove this test. http://crbug.com/706408
 TEST_F(MediaStreamAudioProcessorTest, ValidateBadConstraints) {
   MockConstraintFactory constraint_factory;
   // Add a constraint that is not valid for audio.
   constraint_factory.basic().width.SetExact(240);
   MediaAudioConstraints audio_constraints(
       constraint_factory.CreateWebMediaConstraints(), 0);
   EXPECT_FALSE(audio_constraints.IsValid());
 }
 
+// TODO(guidou): Remove this test. http://crbug.com/706408
 TEST_F(MediaStreamAudioProcessorTest, ValidateGoodConstraints) {
   MockConstraintFactory constraint_factory;
   // Check that the renderToAssociatedSink constraint is considered valid.
   constraint_factory.basic().render_to_associated_sink.SetExact(true);
   MediaAudioConstraints audio_constraints(
       constraint_factory.CreateWebMediaConstraints(), 0);
   EXPECT_TRUE(audio_constraints.IsValid());
 }
 
+// TODO(guidou): Remove this test. http://crbug.com/706408
 TEST_F(MediaStreamAudioProcessorTest, NoEchoTurnsOffProcessing) {
   {
     MockConstraintFactory constraint_factory;
     MediaAudioConstraints audio_constraints(
         constraint_factory.CreateWebMediaConstraints(), 0);
     // The default value for echo cancellation is true, except when all
     // audio processing has been turned off.
     EXPECT_TRUE(audio_constraints.default_audio_processing_constraint_value());
   }
   // Turning off audio processing via a mandatory constraint.
   {
     MockConstraintFactory constraint_factory;
     constraint_factory.basic().echo_cancellation.SetExact(false);
     MediaAudioConstraints audio_constraints(
         constraint_factory.CreateWebMediaConstraints(), 0);
     // The default value for echo cancellation is true, except when all
     // audio processing has been turned off.
     EXPECT_FALSE(audio_constraints.default_audio_processing_constraint_value());
   }
   // Turning off audio processing via an optional constraint.
   {
     MockConstraintFactory constraint_factory;
     constraint_factory.AddAdvanced().echo_cancellation.SetExact(false);
     MediaAudioConstraints audio_constraints(
         constraint_factory.CreateWebMediaConstraints(), 0);
     EXPECT_FALSE(audio_constraints.default_audio_processing_constraint_value());
   }
 }
 
+// TODO(guidou): Remove this function. http://crbug.com/706408
 MediaAudioConstraints MakeMediaAudioConstraints(
     const MockConstraintFactory& constraint_factory) {
   return MediaAudioConstraints(constraint_factory.CreateWebMediaConstraints(),
                                AudioParameters::NO_EFFECTS);
 }
 
+// TODO(guidou): Remove this test. http://crbug.com/706408
 TEST_F(MediaStreamAudioProcessorTest, SelectsConstraintsArrayGeometryIfExists) {
-  std::vector<webrtc::Point> constraints_geometry(1,
-                                                  webrtc::Point(-0.02f, 0, 0));
-  constraints_geometry.push_back(webrtc::Point(0.02f, 0, 0));
+  std::vector<media::Point> constraints_geometry(1, media::Point(-0.02f, 0, 0));
+  constraints_geometry.push_back(media::Point(0.02f, 0, 0));
 
-  std::vector<webrtc::Point> input_device_geometry(1, webrtc::Point(0, 0, 0));
-  input_device_geometry.push_back(webrtc::Point(0, 0.05f, 0));
+  std::vector<media::Point> input_device_geometry(1, media::Point(0, 0, 0));
+  input_device_geometry.push_back(media::Point(0, 0.05f, 0));
 
   {
     // Both geometries empty.
     MockConstraintFactory constraint_factory;
     MediaStreamDevice::AudioDeviceParameters input_params;
 
     const auto& actual_geometry = GetArrayGeometryPreferringConstraints(
         MakeMediaAudioConstraints(constraint_factory), input_params);
-    EXPECT_EQ(std::vector<webrtc::Point>(), actual_geometry);
+    EXPECT_EQ(std::vector<media::Point>(), actual_geometry);
   }
   {
     // Constraints geometry empty.
     MockConstraintFactory constraint_factory;
     MediaStreamDevice::AudioDeviceParameters input_params;
     input_params.mic_positions.push_back(media::Point(0, 0, 0));
     input_params.mic_positions.push_back(media::Point(0, 0.05f, 0));
 
     const auto& actual_geometry = GetArrayGeometryPreferringConstraints(
         MakeMediaAudioConstraints(constraint_factory), input_params);
@@ skipping 26 matching lines @@
   }
 }
 
 // Test crashing with ASAN on Android. crbug.com/468762
 #if defined(OS_ANDROID) && defined(ADDRESS_SANITIZER)
 #define MAYBE_TestAllSampleRates DISABLED_TestAllSampleRates
 #else
 #define MAYBE_TestAllSampleRates TestAllSampleRates
 #endif
 TEST_F(MediaStreamAudioProcessorTest, MAYBE_TestAllSampleRates) {
-  MockConstraintFactory constraint_factory;
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
+  AudioProcessingProperties properties;
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new rtc::RefCountedObject<MediaStreamAudioProcessor>(
-          constraint_factory.CreateWebMediaConstraints(), input_device_params_,
-          webrtc_audio_device.get()));
+          properties, webrtc_audio_device.get()));
   EXPECT_TRUE(audio_processor->has_audio_processing());
 
   static const int kSupportedSampleRates[] =
       { 8000, 16000, 22050, 32000, 44100, 48000 };
   for (size_t i = 0; i < arraysize(kSupportedSampleRates); ++i) {
     int buffer_size = (kSupportedSampleRates[i] / 100)  < 128 ?
         kSupportedSampleRates[i] / 100 : 128;
     media::AudioParameters params(
         media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
         media::CHANNEL_LAYOUT_STEREO, kSupportedSampleRates[i], 16,
@@ skipping 13 matching lines @@
 }
 
 // Test that if we have an AEC dump message filter created, we are getting it
 // correctly in MSAP. Any IPC messages will be deleted since no sender in the
 // filter will be created.
 TEST_F(MediaStreamAudioProcessorTest, GetAecDumpMessageFilter) {
   scoped_refptr<AecDumpMessageFilter> aec_dump_message_filter_(
       new AecDumpMessageFilter(base::ThreadTaskRunnerHandle::Get(),
                                base::ThreadTaskRunnerHandle::Get()));
 
-  MockConstraintFactory constraint_factory;
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
+  AudioProcessingProperties properties;
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new rtc::RefCountedObject<MediaStreamAudioProcessor>(
-          constraint_factory.CreateWebMediaConstraints(), input_device_params_,
-          webrtc_audio_device.get()));
+          properties, webrtc_audio_device.get()));
 
   EXPECT_TRUE(audio_processor->aec_dump_message_filter_.get());
 
   // Stop |audio_processor| so that it removes itself from
   // |webrtc_audio_device| and clears its pointer to it.
   audio_processor->Stop();
 }
 
 TEST_F(MediaStreamAudioProcessorTest, TestStereoAudio) {
-  // Set up the correct constraints to turn off the audio processing and turn
-  // on the stereo channels mirroring.
-  MockConstraintFactory constraint_factory;
-  constraint_factory.basic().echo_cancellation.SetExact(false);
-  constraint_factory.basic().goog_audio_mirroring.SetExact(true);
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
+  AudioProcessingProperties properties;
+  // Turn off the audio processing and turn on the stereo channels mirroring.
+  DisableDefaultAudioProcessingProperties(&properties);

[hbos_chromium, 2017/06/16 17:27:14]

Before, only echo cancellation was disabled and mirroring enabled. Now all of
them are except mirroring, why?

[Guido Urdaneta, 2017/06/19 11:56:48]

The old test was disabling all audio-processing constraints via the old
constraints algorithm by setting the echoCancellation constraint to false.
Similarly, the old test was using constraints to enable audio mirroring.

The new version of the test does not use constraints, but sets the values of
properties explicitly since the MSAP no longer performs constraints processing.

[hbos_chromium, 2017/06/19 15:14:41]

Acknowledged.

+  properties.goog_audio_mirroring = true;
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new rtc::RefCountedObject<MediaStreamAudioProcessor>(
-          constraint_factory.CreateWebMediaConstraints(), input_device_params_,
-          webrtc_audio_device.get()));
+          properties, webrtc_audio_device.get()));
   EXPECT_FALSE(audio_processor->has_audio_processing());
   const media::AudioParameters source_params(
       media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
       media::CHANNEL_LAYOUT_STEREO, 48000, 16, 480);
   audio_processor->OnCaptureFormatChanged(source_params);
   // There's no sense in continuing if this fails.
   ASSERT_EQ(2, audio_processor->OutputFormat().channels());
 
   // Construct left and right channels, and assign different values to the
   // first data of the left channel and right channel.
@@ skipping 35 matching lines @@
   audio_processor->Stop();
 }
 
 // Disabled on android clang builds due to crbug.com/470499
 #if defined(__clang__) && defined(OS_ANDROID)
 #define MAYBE_TestWithKeyboardMicChannel DISABLED_TestWithKeyboardMicChannel
 #else
 #define MAYBE_TestWithKeyboardMicChannel TestWithKeyboardMicChannel
 #endif
 TEST_F(MediaStreamAudioProcessorTest, MAYBE_TestWithKeyboardMicChannel) {
-  MockConstraintFactory constraint_factory;
-  constraint_factory.basic().goog_experimental_noise_suppression.SetExact(true);
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
+  AudioProcessingProperties properties;

[hbos_chromium, 2017/06/16 17:27:14]

goog_experimental_noise_suppression is not set to true and the test still
passes, why? Does its value not matter or is there an assumption about the
default being true? Can you set it anyway or DCHECK that it's true?

[Guido Urdaneta, 2017/06/19 11:56:48]

The default value is true on all platforms, so it's not necessary to set it to
true.
I guess the old test was originally written when the default value was false, or
tried to make sure that it's true even if the default changes.
I think relying on the default true value is better than explicitly setting
since the test would fail if the default changes, which is what applications
would do. This would bring the attention of the people making the change as to
the consequences in the wild.

[hbos_chromium, 2017/06/19 15:14:41]

Acknowledged. I'd still like a comment and/or DCHECK so that the variable
relevant to the test is not completely absent.

   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new rtc::RefCountedObject<MediaStreamAudioProcessor>(
-          constraint_factory.CreateWebMediaConstraints(), input_device_params_,
-          webrtc_audio_device.get()));
+          properties, webrtc_audio_device.get()));
   EXPECT_TRUE(audio_processor->has_audio_processing());
 
   media::AudioParameters params(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
                                 media::CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC,
                                 48000, 16, 512);
   audio_processor->OnCaptureFormatChanged(params);
 
   ProcessDataAndVerifyFormat(audio_processor.get(),
                              kAudioProcessingSampleRate,
                              kAudioProcessingNumberOfChannel,
                              kAudioProcessingSampleRate / 100);
 
   // Stop |audio_processor| so that it removes itself from
   // |webrtc_audio_device| and clears its pointer to it.
   audio_processor->Stop();
 }
 
 // Test that the OnAec3Enable method has the desired effect on the APM config.
 TEST_F(MediaStreamAudioProcessorTest, TestAec3Switch) {
-  MockConstraintFactory constraint_factory;
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
+  AudioProcessingProperties properties;
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new rtc::RefCountedObject<MediaStreamAudioProcessor>(
-          constraint_factory.CreateWebMediaConstraints(), input_device_params_,
-          webrtc_audio_device.get()));
+          properties, webrtc_audio_device.get()));
 
   audio_processor->OnAec3Enable(true);
   EXPECT_TRUE(GetAec3ConfigState(audio_processor.get()));
 
   audio_processor->OnAec3Enable(false);
   EXPECT_FALSE(GetAec3ConfigState(audio_processor.get()));
 
   // Stop |audio_processor| so that it removes itself from
   // |webrtc_audio_device| and clears its pointer to it.
   audio_processor->Stop();
 }
 
 // Same test as above, but when AEC is disabled in the constrants. The expected
 // outcome is that AEC3 should be disabled in all cases.
 TEST_F(MediaStreamAudioProcessorTest, TestAec3Switch_AecOff) {
-  MockConstraintFactory constraint_factory;
-  // Disable the AEC.
-  constraint_factory.DisableAecAudioConstraints();
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
+  AudioProcessingProperties properties;
+  // Disable the AEC.
+  properties.enable_sw_echo_cancellation = false;
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new rtc::RefCountedObject<MediaStreamAudioProcessor>(
-          constraint_factory.CreateWebMediaConstraints(), input_device_params_,
-          webrtc_audio_device.get()));
+          properties, webrtc_audio_device.get()));
 
   EXPECT_FALSE(GetAec3ConfigState(audio_processor.get()));
 
   audio_processor->OnAec3Enable(true);
   EXPECT_FALSE(GetAec3ConfigState(audio_processor.get()));
 
   audio_processor->OnAec3Enable(false);
   EXPECT_FALSE(GetAec3ConfigState(audio_processor.get()));
 
   // Stop |audio_processor| so that it removes itself from
   // |webrtc_audio_device| and clears its pointer to it.
   audio_processor->Stop();
 }
 
 }  // namespace content