Use LocalMediaStreamAudioSource for screen-casting use cases.

content/renderer/media/media_stream_audio_processor.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 "content/renderer/media/media_stream_audio_processor.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
@@ skipping 431 matching lines @@
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (audio_processing_)
     StopEchoCancellationDump(audio_processing_.get());
 }
 
 void MediaStreamAudioProcessor::OnIpcClosing() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   aec_dump_message_filter_ = NULL;
 }
 
+// static
+bool MediaStreamAudioProcessor::WouldModifyAudio(
+    const blink::WebMediaConstraints& constraints,
+    int effects_flags) {
+  // Note: This method should by kept in-sync with any changes to the logic in
+  // MediaStreamAudioProcessor::InitializeAudioProcessingModule().
+
+  const MediaAudioConstraints audio_constraints(constraints, effects_flags);
+
+  if (audio_constraints.GetGoogAudioMirroring())
+    return true;
+
+#if !defined(OS_IOS)
+  if (audio_constraints.GetEchoCancellationProperty() ||
+      audio_constraints.GetGoogAutoGainControl()) {
+    return true;
+  }
+#endif
+
+#if !defined(OS_IOS) && !defined(OS_ANDROID)
+  if (audio_constraints.GetGoogExperimentalEchoCancellation() ||
+      audio_constraints.GetGoogTypingNoiseDetection()) {
+    return true;
+  }
+#endif
+
+  if (audio_constraints.GetGoogNoiseSuppression() ||
+      audio_constraints.GetGoogExperimentalNoiseSuppression() ||
+      audio_constraints.GetGoogBeamforming() ||
+      audio_constraints.GetGoogHighpassFilter()) {
+    return true;
+  }
+
+  return false;
+}
+
 void MediaStreamAudioProcessor::OnPlayoutData(media::AudioBus* audio_bus,
                                               int sample_rate,
                                               int audio_delay_milliseconds) {
   DCHECK(render_thread_checker_.CalledOnValidThread());
 #if defined(OS_ANDROID)
   DCHECK(audio_processing_->echo_control_mobile()->is_enabled());
   DCHECK(!audio_processing_->echo_cancellation()->is_enabled());
 #else
   DCHECK(!audio_processing_->echo_control_mobile()->is_enabled());
   DCHECK(audio_processing_->echo_cancellation()->is_enabled());
@@ skipping 42 matching lines @@
 }
 
 void MediaStreamAudioProcessor::InitializeAudioProcessingModule(
     const blink::WebMediaConstraints& constraints,
     const MediaStreamDevice::AudioDeviceParameters& input_params) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(!audio_processing_);
 
   MediaAudioConstraints audio_constraints(constraints, input_params.effects);
 
-  // Audio mirroring can be enabled even though audio processing is otherwise
-  // disabled.
+  // Note: The audio mirroring constraint (i.e., swap left and right channels)
+  // is handled within this MediaStreamAudioProcessor and does not, by itself,
+  // require webrtc::AudioProcessing.
   audio_mirroring_ = audio_constraints.GetGoogAudioMirroring();
 
   const bool echo_cancellation =
       audio_constraints.GetEchoCancellationProperty();
   const bool goog_agc = audio_constraints.GetGoogAutoGainControl();
 
 #if defined(OS_ANDROID)
   const bool goog_experimental_aec = false;
   const bool goog_typing_detection = false;
 #else
   const bool goog_experimental_aec =
       audio_constraints.GetGoogExperimentalEchoCancellation();
   const bool goog_typing_detection =
       audio_constraints.GetGoogTypingNoiseDetection();
 #endif
 
   const bool goog_ns = audio_constraints.GetGoogNoiseSuppression();
   const bool goog_experimental_ns =
       audio_constraints.GetGoogExperimentalNoiseSuppression();
   const bool goog_beamforming = audio_constraints.GetGoogBeamforming();
   const bool goog_high_pass_filter = audio_constraints.GetGoogHighpassFilter();
-  // Return immediately if no goog constraint is enabled.
+
+  // Return immediately if none of the goog constraints requiring
+  // webrtc::AudioProcessing are enabled.
   if (!echo_cancellation && !goog_experimental_aec && !goog_ns &&
       !goog_high_pass_filter && !goog_typing_detection &&
       !goog_agc && !goog_experimental_ns && !goog_beamforming) {
+    // Sanity-check: WouldModifyAudio() should return true iff
+    // |audio_mirroring_| is true.
+    DCHECK_EQ(audio_mirroring_, WouldModifyAudio(constraints,
+                                                 input_params.effects));
     RecordProcessingState(AUDIO_PROCESSING_DISABLED);
     return;
   }
 
+  // Sanity-check: WouldModifyAudio() should return true because the above logic
+  // has determined webrtc::AudioProcessing will be used.
+  DCHECK(WouldModifyAudio(constraints, input_params.effects));
+
   // Experimental options provided at creation.
   webrtc::Config config;
   config.Set<webrtc::ExtendedFilter>(
       new webrtc::ExtendedFilter(goog_experimental_aec));
   config.Set<webrtc::ExperimentalNs>(
       new webrtc::ExperimentalNs(goog_experimental_ns));
   config.Set<webrtc::DelayAgnostic>(new webrtc::DelayAgnostic(true));
   if (UseAecRefinedAdaptiveFilter()) {
     config.Set<webrtc::RefinedAdaptiveFilter>(
         new webrtc::RefinedAdaptiveFilter(true));
@@ skipping 215 matching lines @@
       0 : agc->stream_analog_level();
 }
 
 void MediaStreamAudioProcessor::UpdateAecStats() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (echo_information_)
     echo_information_->UpdateAecStats(audio_processing_->echo_cancellation());
 }
 
 }  // namespace content