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::ShouldRouteAudioThroughProcessor(
+    const blink::WebMediaConstraints& constraints,
+    int effects_flags) {
+  // Note: This method should by kept in-sync with any changes to the logic in
+  // MediaStreamAudioProcessor::InitializeAudioProcessingModule().

[xjz, 2016/08/13 00:43:56]

nit: The logic here is in sync with that in
MediaStreamAudioProcessor::IniitializeAudioProcessingModule() except for the
GetGoogAudioMirroring() on Line 461. Can we move this comment below that logic,
e.g.,  to Line 463, and s/This method/The following ?

[miu, 2016/08/16 04:30:02]

Actually, it's perfectly in-sync. If GetGoogAudioMirroring() returns true,
MediaStreamAudioProcessor will reverse the left and right channels of the audio.
So, the method should return true because the constraints would cause the audio
signal to be modified.

+
+  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

[o1ka, 2016/08/15 15:15:00]

ShouldRouteAudioThroughProcessor() always returns true when audio mirroring is
enabled. Do you mean by this comment that audio processing is on if mirroring is
on? Or do you meant that even if mirroring is on audio processing may be off?
(If latter, than why ShouldRouteAudioThroughProcessor() returns true?)

[miu, 2016/08/16 04:30:02]

This comment was confusing; and I've fixed it to correctly explain what the
implementation will do.

   // disabled.
   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.
   if (!echo_cancellation && !goog_experimental_aec && !goog_ns &&
       !goog_high_pass_filter && !goog_typing_detection &&
       !goog_agc && !goog_experimental_ns && !goog_beamforming) {
+    // Ensure ShouldRouteAudioThroughProcessor() is kept in-sync with all of the
+    // above logic.
+    DCHECK_EQ(audio_mirroring_, ShouldRouteAudioThroughProcessor(

[o1ka, 2016/08/15 15:15:00]

See the comment above: it's confusing when ShouldRouteAudioThroughProcessor() is
true, but AUDIO_PROCESSING_DISABLED is set. What is the actual meaning of this
"Should..." method then?

[miu, 2016/08/16 04:30:02]

I made some clarifications on these comments too. Also, I've renamed the
ShouldRouteAudioThroughProcessor() function to WouldModifyAudio() and updated
the header file comments.

+                                    constraints, input_params.effects));
     RecordProcessingState(AUDIO_PROCESSING_DISABLED);
     return;
+  } else {
+    // Ensure ShouldRouteAudioThroughProcessor() is kept in-sync with all of the
+    // above logic.
+    DCHECK(ShouldRouteAudioThroughProcessor(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()) {
@@ skipping 217 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