Added a kEchoCancellation constraint to turn off the audio processing.

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 "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/time/time.h"
 #include "content/public/common/content_switches.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_media_constraint_factory.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/audio_bus.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/libjingle/source/talk/app/webrtc/mediastreaminterface.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
@@ skipping 122 matching lines @@
     EXPECT_TRUE(audio_processing->voice_detection()->likelihood() ==
         webrtc::VoiceDetection::kVeryLowLikelihood);
 #endif
   }
 
   media::AudioParameters params_;
 };
 
 TEST_F(MediaStreamAudioProcessorTest, WithoutAudioProcessing) {
   // Setup the audio processor without enabling the flag.
-  blink::WebMediaConstraints constraints;
+  MockMediaConstraintFactory constraint_factory;
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new talk_base::RefCountedObject<MediaStreamAudioProcessor>(
-          constraints, 0, MEDIA_DEVICE_AUDIO_CAPTURE,
-          webrtc_audio_device.get()));
+          constraint_factory.CreateWebMediaConstraints(), 0,
+          MEDIA_DEVICE_AUDIO_CAPTURE, webrtc_audio_device.get()));
   EXPECT_FALSE(audio_processor->has_audio_processing());
   audio_processor->OnCaptureFormatChanged(params_);
 
   ProcessDataAndVerifyFormat(audio_processor,
                              params_.sample_rate(),
                              params_.channels(),
                              params_.sample_rate() / 100);
   // Set |audio_processor| to NULL to make sure |webrtc_audio_device| outlives
   // |audio_processor|.
   audio_processor = NULL;
 }
 
 TEST_F(MediaStreamAudioProcessorTest, WithAudioProcessing) {
   // Setup the audio processor with the flag enabled.
   CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableAudioTrackProcessing);
-  blink::WebMediaConstraints constraints;
+  MockMediaConstraintFactory constraint_factory;
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new talk_base::RefCountedObject<MediaStreamAudioProcessor>(
-          constraints, 0, MEDIA_DEVICE_AUDIO_CAPTURE,
-          webrtc_audio_device.get()));
+          constraint_factory.CreateWebMediaConstraints(), 0,
+          MEDIA_DEVICE_AUDIO_CAPTURE, webrtc_audio_device.get()));
   EXPECT_TRUE(audio_processor->has_audio_processing());
   audio_processor->OnCaptureFormatChanged(params_);
   VerifyDefaultComponents(audio_processor);
 
   ProcessDataAndVerifyFormat(audio_processor,
                              kAudioProcessingSampleRate,
                              kAudioProcessingNumberOfChannel,
                              kAudioProcessingSampleRate / 100);
   // Set |audio_processor| to NULL to make sure |webrtc_audio_device| outlives
   // |audio_processor|.
   audio_processor = NULL;
 }
 
 TEST_F(MediaStreamAudioProcessorTest, VerifyTabCaptureWithoutAudioProcessing) {
   // Setup the audio processor with enabling the flag.
   CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableAudioTrackProcessing);
-  blink::WebMediaConstraints constraints;
+  MockMediaConstraintFactory constraint_factory;
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   // Create MediaStreamAudioProcessor instance for MEDIA_TAB_AUDIO_CAPTURE type.
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new talk_base::RefCountedObject<MediaStreamAudioProcessor>(
-          constraints, 0, MEDIA_TAB_AUDIO_CAPTURE,
-          webrtc_audio_device.get()));
+          constraint_factory.CreateWebMediaConstraints(), 0,
+          MEDIA_TAB_AUDIO_CAPTURE, webrtc_audio_device.get()));
   EXPECT_FALSE(audio_processor->has_audio_processing());
   audio_processor->OnCaptureFormatChanged(params_);
 
   ProcessDataAndVerifyFormat(audio_processor,
                              params_.sample_rate(),
                              params_.channels(),
                              params_.sample_rate() / 100);
 
   // Create MediaStreamAudioProcessor instance for MEDIA_LOOPBACK_AUDIO_CAPTURE.
   audio_processor =
       new talk_base::RefCountedObject<MediaStreamAudioProcessor>(
-          constraints, 0, MEDIA_LOOPBACK_AUDIO_CAPTURE,
-          webrtc_audio_device.get());
+          constraint_factory.CreateWebMediaConstraints(), 0,
+          MEDIA_LOOPBACK_AUDIO_CAPTURE, webrtc_audio_device.get());
   EXPECT_FALSE(audio_processor->has_audio_processing());
 
   // Set |audio_processor| to NULL to make sure |webrtc_audio_device| outlives
   // |audio_processor|.
   audio_processor = NULL;
 }
 
 TEST_F(MediaStreamAudioProcessorTest, TurnOffDefaultConstraints) {
   // Setup the audio processor with enabling the flag.
   CommandLine::ForCurrentProcess()->AppendSwitch(
@@ skipping 13 matching lines @@
 
   ProcessDataAndVerifyFormat(audio_processor,
                              params_.sample_rate(),
                              params_.channels(),
                              params_.sample_rate() / 100);
   // Set |audio_processor| to NULL to make sure |webrtc_audio_device| outlives
   // |audio_processor|.
   audio_processor = NULL;
 }
 
+TEST_F(MediaStreamAudioProcessorTest, VerifyConstraints) {
+  // Setup the audio processor with enabling the flag.
+  CommandLine::ForCurrentProcess()->AppendSwitch(
+      switches::kEnableAudioTrackProcessing);
+
+  static const char* kDefaultAudioConstraints[] = {
+      kEchoCancellation,

[tommi (sloooow) - chröme, 2014/04/08 10:49:30]

fix indent

[no longer working on chromium, 2014/04/11 08:56:30]

Done.

+      kGoogEchoCancellation,
+      kGoogExperimentalEchoCancellation,
+      kGoogAutoGainControl,
+      kGoogExperimentalAutoGainControl,
+      kGoogNoiseSuppression,
+      kGoogExperimentalNoiseSuppression,
+      kGoogHighpassFilter,
+      kGoogTypingNoiseDetection,
+      kGoogAudioMirroring
+  };
+
+  // Verify mandatory constraints.
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kDefaultAudioConstraints); ++i) {
+    MockMediaConstraintFactory constraint_factory;
+    constraint_factory.AddMandatory(kDefaultAudioConstraints[i], false);

[tommi (sloooow) - chröme, 2014/04/08 10:49:30]

looks like you're exchanging bool for what used to be a string...

[no longer working on chromium, 2014/04/11 08:56:30]

MockMediaConstraintFactory::AddMandatory takes int or double as input.

I guess you meant RTCMediaConstraints, which takes string as input.

Some background information, RTCMediaConstraints is the helper class to parse
blink constraints to libjingle constraints, it takes strings as input.

While blink::WebMediaConstraints tales int or double converted strings as
values.

+    blink::WebMediaConstraints constraints =
+        constraint_factory.CreateWebMediaConstraints();
+    EXPECT_FALSE(GetPropertyFromConstraints(constraints,
+                                            kDefaultAudioConstraints[i],
+                                            0, MEDIA_DEVICE_AUDIO_CAPTURE));
+  }
+
+  // Verify optional constraints.
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kDefaultAudioConstraints); ++i) {
+    MockMediaConstraintFactory constraint_factory;
+    constraint_factory.AddOptional(kDefaultAudioConstraints[i], false);
+    blink::WebMediaConstraints constraints =
+        constraint_factory.CreateWebMediaConstraints();
+    EXPECT_FALSE(GetPropertyFromConstraints(constraints,
+                                            kDefaultAudioConstraints[i],
+                                            0, MEDIA_DEVICE_AUDIO_CAPTURE));
+  }
+
+ // Verify echo cancellation is off when platform aec effect is on.
+  MockMediaConstraintFactory constraint_factory;
+  EXPECT_FALSE(GetPropertyFromConstraints(
+      constraint_factory.CreateWebMediaConstraints(),
+      kGoogEchoCancellation,
+      media::AudioParameters::ECHO_CANCELLER, MEDIA_DEVICE_AUDIO_CAPTURE));
+}
+

[perkj_chrome, 2014/04/08 10:28:12]

Add test to see that gum fail if an unsupported mandatory constraint is
specified?

[no longer working on chromium, 2014/04/11 08:56:30]

Done.

 }  // namespace content