Only turn on the audio processing by default for MEDIA_DEVICE_AUDIO_CAPTURE.

Then other clients of MEDIA_TAB_AUDIO_CAPTURE, MEDIA_TAB_VIDEO_CAPTURE, MEDIA_LOOPBACK_AUDIO_CAPTURE won't have the audio processing unless the users explicitly turn on the constraints.

NOTRY=true

BUG=264611

Review URL: https://codereview.chromium.org/190713004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@255975 0039d316-1c4b-4281-b951-d872f2087c98

content/renderer/media/media_stream_audio_processor.cc

@@ -142,6 +142,7 @@ class MediaStreamAudioProcessor::MediaStreamAudioConverter
 MediaStreamAudioProcessor::MediaStreamAudioProcessor(
     const blink::WebMediaConstraints& constraints,
     int effects,
+    MediaStreamType type,
     WebRtcPlayoutDataSource* playout_data_source)
     : render_delay_ms_(0),
       playout_data_source_(playout_data_source),
@@ -149,7 +150,7 @@ MediaStreamAudioProcessor::MediaStreamAudioProcessor(
       typing_detected_(false) {
   capture_thread_checker_.DetachFromThread();
   render_thread_checker_.DetachFromThread();
-  InitializeAudioProcessingModule(constraints, effects);
+  InitializeAudioProcessingModule(constraints, effects, type);
 }
 
 MediaStreamAudioProcessor::~MediaStreamAudioProcessor() {
@@ -260,7 +261,8 @@ void MediaStreamAudioProcessor::GetStats(AudioProcessorStats* stats) {
 }
 
 void MediaStreamAudioProcessor::InitializeAudioProcessingModule(
-    const blink::WebMediaConstraints& constraints, int effects) {
+    const blink::WebMediaConstraints& constraints, int effects,
+    MediaStreamType type) {
   DCHECK(!audio_processing_);
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableAudioTrackProcessing)) {
@@ -268,7 +270,12 @@ void MediaStreamAudioProcessor::InitializeAudioProcessingModule(
   }
 
   RTCMediaConstraints native_constraints(constraints);
+
+  // Only apply the fixed constraints for gUM of MEDIA_DEVICE_AUDIO_CAPTURE.
+  DCHECK(IsAudioMediaType(type));
+  if (type == MEDIA_DEVICE_AUDIO_CAPTURE)
     ApplyFixedAudioConstraints(&native_constraints);
+
   if (effects & media::AudioParameters::ECHO_CANCELLER) {
     // If platform echo canceller is enabled, disable the software AEC.
     native_constraints.AddMandatory(

content/renderer/media/media_stream_audio_processor.h

@@ -11,6 +11,7 @@
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "content/common/content_export.h"
+#include "content/public/common/media_stream_request.h"
 #include "content/renderer/media/webrtc_audio_device_impl.h"
 #include "media/base/audio_converter.h"
 #include "third_party/libjingle/source/talk/app/webrtc/mediastreaminterface.h"
@@ -51,6 +52,7 @@ class CONTENT_EXPORT MediaStreamAudioProcessor :
   // |playout_data_source| won't be used.
   MediaStreamAudioProcessor(const blink::WebMediaConstraints& constraints,
                             int effects,
+                            MediaStreamType type,
                             WebRtcPlayoutDataSource* playout_data_source);
 
   // Called when format of the capture data has changed.
@@ -119,7 +121,8 @@ class CONTENT_EXPORT MediaStreamAudioProcessor :
 
   // Helper to initialize the WebRtc AudioProcessing.
   void InitializeAudioProcessingModule(
-      const blink::WebMediaConstraints& constraints, int effects);
+      const blink::WebMediaConstraints& constraints, int effects,
+      MediaStreamType type);
 
   // Helper to initialize the capture converter.
   void InitializeCaptureConverter(const media::AudioParameters& source_params);

content/renderer/media/media_stream_audio_processor_unittest.cc

@@ -9,6 +9,7 @@
 #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 "media/audio/audio_parameters.h"
 #include "media/base/audio_bus.h"
@@ -156,7 +157,8 @@ TEST_F(MediaStreamAudioProcessorTest, WithoutAudioProcessing) {
       new WebRtcAudioDeviceImpl());
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new talk_base::RefCountedObject<MediaStreamAudioProcessor>(
-          constraints, 0, webrtc_audio_device.get()));
+          constraints, 0, MEDIA_DEVICE_AUDIO_CAPTURE,
+          webrtc_audio_device.get()));
   EXPECT_FALSE(audio_processor->has_audio_processing());
   audio_processor->OnCaptureFormatChanged(params_);
 
@@ -178,7 +180,8 @@ TEST_F(MediaStreamAudioProcessorTest, WithAudioProcessing) {
       new WebRtcAudioDeviceImpl());
   scoped_refptr<MediaStreamAudioProcessor> audio_processor(
       new talk_base::RefCountedObject<MediaStreamAudioProcessor>(
-          constraints, 0, webrtc_audio_device.get()));
+          constraints, 0, MEDIA_DEVICE_AUDIO_CAPTURE,
+          webrtc_audio_device.get()));
   EXPECT_TRUE(audio_processor->has_audio_processing());
   audio_processor->OnCaptureFormatChanged(params_);
   VerifyDefaultComponents(audio_processor);
@@ -192,4 +195,36 @@ TEST_F(MediaStreamAudioProcessorTest, WithAudioProcessing) {
   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.
+  scoped_refptr<MediaStreamAudioProcessor> audio_processor(
+      new talk_base::RefCountedObject<MediaStreamAudioProcessor>(
+          constraints, 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());
+  EXPECT_FALSE(audio_processor->has_audio_processing());
+
+  // Set |audio_processor| to NULL to make sure |webrtc_audio_device| outlives
+  // |audio_processor|.
+  audio_processor = NULL;
+}
+
 }  // namespace content

content/renderer/media/webrtc/webrtc_local_audio_track_adapter_unittest.cc

@@ -35,7 +35,8 @@ class WebRtcLocalAudioTrackAdapterTest : public ::testing::Test {
                 media::CHANNEL_LAYOUT_STEREO, 48000, 16, 480),
         adapter_(WebRtcLocalAudioTrackAdapter::Create(std::string(), NULL)),
         capturer_(WebRtcAudioCapturer::CreateCapturer(
-            -1, StreamDeviceInfo(), blink::WebMediaConstraints(), NULL)),
+            -1, StreamDeviceInfo(MEDIA_DEVICE_AUDIO_CAPTURE, "", ""),
+            blink::WebMediaConstraints(), NULL)),
         track_(new WebRtcLocalAudioTrack(adapter_, capturer_, NULL)) {}
 
  protected:

content/renderer/media/webrtc_audio_capturer.cc

@@ -212,7 +212,8 @@ WebRtcAudioCapturer::WebRtcAudioCapturer(
     : constraints_(constraints),
       audio_processor_(
           new talk_base::RefCountedObject<MediaStreamAudioProcessor>(
-              constraints, device_info.device.input.effects, audio_device)),
+              constraints, device_info.device.input.effects,
+              device_info.device.type, audio_device)),
       running_(false),
       render_view_id_(render_view_id),
       device_info_(device_info),

content/renderer/media/webrtc_local_audio_track_unittest.cc

@@ -164,7 +164,9 @@ class WebRtcLocalAudioTrackTest : public ::testing::Test {
     params_.Reset(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
                   media::CHANNEL_LAYOUT_STEREO, 2, 0, 48000, 16, 480);
     blink::WebMediaConstraints constraints;
-    capturer_ = WebRtcAudioCapturer::CreateCapturer(-1, StreamDeviceInfo(),
+    StreamDeviceInfo device(MEDIA_DEVICE_AUDIO_CAPTURE,
+                            std::string(), std::string());
+    capturer_ = WebRtcAudioCapturer::CreateCapturer(-1, device,
                                                     constraints, NULL);
     capturer_source_ = new MockCapturerSource(capturer_.get());
     EXPECT_CALL(*capturer_source_.get(), OnInitialize(_, capturer_.get(), -1))
@@ -471,9 +473,10 @@ TEST_F(WebRtcLocalAudioTrackTest, ConnectTracksToDifferentCapturers) {
 
   // Create a new capturer with new source with different audio format.
   blink::WebMediaConstraints constraints;
+  StreamDeviceInfo device(MEDIA_DEVICE_AUDIO_CAPTURE,
+                          std::string(), std::string());
   scoped_refptr<WebRtcAudioCapturer> new_capturer(
-      WebRtcAudioCapturer::CreateCapturer(-1, StreamDeviceInfo(),
-                                          constraints, NULL));
+      WebRtcAudioCapturer::CreateCapturer(-1, device, constraints, NULL));
   scoped_refptr<MockCapturerSource> new_source(
       new MockCapturerSource(new_capturer.get()));
   EXPECT_CALL(*new_source.get(), OnInitialize(_, new_capturer.get(), -1));