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"

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

nit: Here and perhaps other files: remove inclusion of mock_constraint_factory.h

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

Done.

 #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(
+    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) {

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

Why is this test removed? If invalid constraints are ignored would the
equivalent test be the same as unconstrained? Should't that succeed?

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

The concept of "wrong" constraints does not exist in the new algorithm the way
it existed with the old one.
If you set a width with the new algorithm it will be the same as unconstrained,
so the corresponding test would be the same as the previous one (using default
values for AudioProcessingProperties).
The spec says that unsupported constraints should be ignored.

-  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