Enable new getUserMedia audio constraints algorithm behind a flag.

content/renderer/media/webrtc/processed_local_audio_source_unittest.cc

 // Copyright 2016 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 <memory>
 #include <string>
 
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "build/build_config.h"
 #include "content/public/renderer/media_stream_audio_sink.h"
+#include "content/renderer/media/media_stream_audio_processor_options.h"
 #include "content/renderer/media/media_stream_audio_track.h"
 #include "content/renderer/media/mock_audio_device_factory.h"
-#include "content/renderer/media/mock_constraint_factory.h"
 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
 #include "content/renderer/media/webrtc/processed_local_audio_source.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/WebKit/public/web/WebHeap.h"
 
 using ::testing::_;
@@ skipping 40 matching lines @@
   void OnSetFormat(const media::AudioParameters& params) override {
     params_ = params;
     FormatIsSet(params_);
   }
   MOCK_METHOD1(FormatIsSet, void(const media::AudioParameters& params));
 
  private:
   media::AudioParameters params_;
 };
 
+void DisableDefaultAudioProcessingProperties(

[miu, 2017/06/19 21:18:44]

Looks like this same code is in two places. I'd suggest making it a method in
AudioProcessingProperties and let it be optimized-out (i.e., removed by the
linker) in release builds.

[Guido Urdaneta, 2017/06/20 12:18:48]

Done.

+    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;
+  properties->goog_highpass_filter = false;
+  properties->goog_typing_noise_detection = false;
+  properties->goog_experimental_noise_suppression = false;
+  properties->goog_beamforming = false;
+}
+
 }  // namespace
 
 class ProcessedLocalAudioSourceTest : public testing::Test {
  protected:
   ProcessedLocalAudioSourceTest() {}
 
   ~ProcessedLocalAudioSourceTest() override {}
 
   void SetUp() override {
     blink_audio_source_.Initialize(blink::WebString::FromUTF8("audio_label"),
                                    blink::WebMediaStreamSource::kTypeAudio,
                                    blink::WebString::FromUTF8("audio_track"),
                                    false /* remote */);
     blink_audio_track_.Initialize(blink_audio_source_.Id(),
                                   blink_audio_source_);
   }
 
   void TearDown() override {
     blink_audio_track_.Reset();
     blink_audio_source_.Reset();
     blink::WebHeap::CollectAllGarbageForTesting();
   }
 
   void CreateProcessedLocalAudioSource(
-      const blink::WebMediaConstraints& constraints) {
+      const AudioProcessingProperties& properties) {
     ProcessedLocalAudioSource* const source = new ProcessedLocalAudioSource(
         -1 /* consumer_render_frame_id is N/A for non-browser tests */,
         StreamDeviceInfo(MEDIA_DEVICE_AUDIO_CAPTURE, "Mock audio device",
                          "mock_audio_device_id", kSampleRate, kChannelLayout,
                          kRequestedBufferSize),
-        constraints,
+        properties,
         base::Bind(&ProcessedLocalAudioSourceTest::OnAudioSourceStarted,
                    base::Unretained(this)),
         &mock_dependency_factory_);
     source->SetAllowInvalidRenderFrameIdForTesting(true);
     blink_audio_source_.SetExtraData(source);  // Takes ownership.
   }
 
   void CheckSourceFormatMatches(const media::AudioParameters& params) {
     EXPECT_EQ(kSampleRate, params.sample_rate());
     EXPECT_EQ(kChannelLayout, params.channel_layout());
@@ skipping 38 matching lines @@
 // Tests a basic end-to-end start-up, track+sink connections, audio flow, and
 // shut-down. The unit tests in media_stream_audio_unittest.cc provide more
 // comprehensive testing of the object graph connections and multi-threading
 // concerns.
 TEST_F(ProcessedLocalAudioSourceTest, VerifyAudioFlowWithoutAudioProcessing) {
   using ThisTest =
       ProcessedLocalAudioSourceTest_VerifyAudioFlowWithoutAudioProcessing_Test;
 
   // Turn off the default constraints so the sink will get audio in chunks of
   // the native buffer size.
-  MockConstraintFactory constraint_factory;
-  constraint_factory.DisableDefaultAudioConstraints();
-
-  CreateProcessedLocalAudioSource(
-      constraint_factory.CreateWebMediaConstraints());
+  AudioProcessingProperties properties;
+  DisableDefaultAudioProcessingProperties(&properties);
+  CreateProcessedLocalAudioSource(properties);
 
   // Connect the track, and expect the MockCapturerSource to be initialized and
   // started by ProcessedLocalAudioSource.
   EXPECT_CALL(*mock_audio_device_factory()->mock_capturer_source(),
               Initialize(_, capture_source_callback(), -1))
       .WillOnce(WithArg<0>(Invoke(this, &ThisTest::CheckSourceFormatMatches)));
   EXPECT_CALL(*mock_audio_device_factory()->mock_capturer_source(),
               SetAutomaticGainControl(true));
   EXPECT_CALL(*mock_audio_device_factory()->mock_capturer_source(), Start())
       .WillOnce(Invoke(
@@ skipping 20 matching lines @@
   EXPECT_CALL(*sink, OnDataCallback()).Times(AtLeast(1));
   capture_source_callback()->Capture(audio_bus.get(), delay_ms, volume,
                                      key_pressed);
 
   // Expect the ProcessedLocalAudioSource to auto-stop the MockCapturerSource
   // when the track is stopped.
   EXPECT_CALL(*mock_audio_device_factory()->mock_capturer_source(), Stop());
   MediaStreamAudioTrack::From(blink_audio_track())->Stop();
 }
 
-// Tests that the source is not started when invalid audio constraints are
-// present.
-TEST_F(ProcessedLocalAudioSourceTest, FailToStartWithWrongConstraints) {
-  MockConstraintFactory constraint_factory;
-  const std::string dummy_constraint = "dummy";
-  // Set a non-audio constraint.
-  constraint_factory.basic().width.SetExact(240);
-
-  CreateProcessedLocalAudioSource(
-      constraint_factory.CreateWebMediaConstraints());
-
-  // Expect the MockCapturerSource is never initialized/started and the
-  // ConnectToTrack() operation fails due to the invalid constraint.
-  EXPECT_CALL(*mock_audio_device_factory()->mock_capturer_source(),
-              Initialize(_, capture_source_callback(), -1))
-      .Times(0);
-  EXPECT_CALL(*mock_audio_device_factory()->mock_capturer_source(),
-              SetAutomaticGainControl(true)).Times(0);
-  EXPECT_CALL(*mock_audio_device_factory()->mock_capturer_source(), Start())
-      .Times(0);
-  EXPECT_FALSE(audio_source()->ConnectToTrack(blink_audio_track()));
-
-  // Even though ConnectToTrack() failed, there should still have been a new
-  // MediaStreamAudioTrack instance created, owned by the
-  // blink::WebMediaStreamTrack.
-  EXPECT_TRUE(MediaStreamAudioTrack::From(blink_audio_track()));
-}
-
-// TODO(miu): There's a lot of logic in ProcessedLocalAudioSource around
-// constraints processing and validation that should have unit testing.
 
 }  // namespace content