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,
+          constraint_factory.CreateWebMediaConstraints(), 0,
           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,
+          constraint_factory.CreateWebMediaConstraints(), 0,
           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;
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
-  // Create MediaStreamAudioProcessor instance for MEDIA_TAB_AUDIO_CAPTURE type.
+  // Create MediaStreamAudioProcessor instance for kMediaStreamSourceTab source.
+  MockMediaConstraintFactory tab_constraint_factory;
+  tab_constraint_factory.AddMandatory(kMediaStreamSource,
+                                      kMediaStreamSourceTab);
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new talk_base::RefCountedObject<MediaStreamAudioProcessor>(
-          constraints, 0, MEDIA_TAB_AUDIO_CAPTURE,
+          tab_constraint_factory.CreateWebMediaConstraints(), 0,
           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());
+  // Create MediaStreamAudioProcessor instance for kMediaStreamSourceSystem
+  // source.
+  MockMediaConstraintFactory system_constraint_factory;
+  system_constraint_factory.AddMandatory(kMediaStreamSource,
+                                         kMediaStreamSourceSystem);
+  audio_processor = new talk_base::RefCountedObject<MediaStreamAudioProcessor>(
+      system_constraint_factory.CreateWebMediaConstraints(), 0,
+      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(
       switches::kEnableAudioTrackProcessing);
 
   // Turn off the default constraints and pass it to MediaStreamAudioProcessor.
   MockMediaConstraintFactory constraint_factory;
   constraint_factory.DisableDefaultAudioConstraints();
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new talk_base::RefCountedObject<MediaStreamAudioProcessor>(
           constraint_factory.CreateWebMediaConstraints(), 0,
-          MEDIA_DEVICE_AUDIO_CAPTURE, webrtc_audio_device.get()));
+          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, VerifyConstraints) {
+  // Setup the audio processor with enabling the flag.
+  CommandLine::ForCurrentProcess()->AppendSwitch(
+      switches::kEnableAudioTrackProcessing);
+
+  static const char* kDefaultAudioConstraints[] = {
+    kEchoCancellation,
+    kGoogEchoCancellation,
+    kGoogExperimentalEchoCancellation,
+    kGoogAutoGainControl,
+    kGoogExperimentalAutoGainControl,
+    kGoogNoiseSuppression,
+    kGoogExperimentalNoiseSuppression,
+    kGoogHighpassFilter,
+    kGoogTypingNoiseDetection,
+    kGoogAudioMirroring
+  };
+
+  // Verify mandatory constraints.
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kDefaultAudioConstraints); ++i) {

[perkj_chrome, 2014/04/11 11:45:04]

why not array_size() ?

[no longer working on chromium, 2014/04/11 16:47:05]

I guess you meant arraysize, if so, done.

+    MockMediaConstraintFactory constraint_factory;
+    constraint_factory.AddMandatory(kDefaultAudioConstraints[i], false);
+    blink::WebMediaConstraints constraints =
+        constraint_factory.CreateWebMediaConstraints();
+    EXPECT_FALSE(GetPropertyFromConstraints(constraints,
+                                            kDefaultAudioConstraints[i],
+                                            0));
+  }
+
+  // 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));
+  }
+
+ // 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));
+}
+
+TEST_F(MediaStreamAudioProcessorTest, VerifyAllMandatoryConstraints) {
+  // Verify gUM will fail if getting an invalid mandatory audio constraint.
+  MockMediaConstraintFactory constraint_factory;
+  const std::string dummy_constraint = "dummy";
+  constraint_factory.AddMandatory(dummy_constraint, true);
+  EXPECT_FALSE(IsValid(constraint_factory.CreateWebMediaConstraints()));
+}
+
 }  // namespace content