Clean up the media stream audio track code

content/renderer/media/webrtc_audio_capturer.cc

 // Copyright (c) 2012 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/webrtc_audio_capturer.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
@@ skipping 29 matching lines @@
 }  // namespace
 
 // Reference counted container of WebRtcLocalAudioTrack delegate.
 // TODO(xians): Switch to MediaStreamAudioSinkOwner.
 class WebRtcAudioCapturer::TrackOwner
     : public base::RefCountedThreadSafe<WebRtcAudioCapturer::TrackOwner> {
  public:
   explicit TrackOwner(WebRtcLocalAudioTrack* track)
       : delegate_(track) {}
 
-  void Capture(const int16* audio_data,
-               base::TimeDelta delay,
-               double volume,
-               bool key_pressed,
-               bool need_audio_processing,
-               bool force_report_nonzero_energy) {
+  void Capture(const int16* audio_data, bool force_report_nonzero_energy) {
     base::AutoLock lock(lock_);
     if (delegate_) {
-      delegate_->Capture(audio_data,
-                         delay,
-                         volume,
-                         key_pressed,
-                         need_audio_processing,
-                         force_report_nonzero_energy);
+      delegate_->Capture(audio_data, force_report_nonzero_energy);
     }
   }
 
   void OnSetFormat(const media::AudioParameters& params) {
     base::AutoLock lock(lock_);
     if (delegate_)
       delegate_->OnSetFormat(params);
   }
 
   void SetAudioProcessor(
@@ skipping 89 matching lines @@
   if (!audio_constraints.IsValid())
     return false;
 
   media::ChannelLayout channel_layout = static_cast<media::ChannelLayout>(
       device_info_.device.input.channel_layout);
 
   // If KEYBOARD_MIC effect is set, change the layout to the corresponding
   // layout that includes the keyboard mic.
   if ((device_info_.device.input.effects &
           media::AudioParameters::KEYBOARD_MIC) &&
-      MediaStreamAudioProcessor::IsAudioTrackProcessingEnabled() &&
       audio_constraints.GetProperty(
           MediaAudioConstraints::kGoogExperimentalNoiseSuppression)) {
     if (channel_layout == media::CHANNEL_LAYOUT_STEREO) {
       channel_layout = media::CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC;
       DVLOG(1) << "Changed stereo layout to stereo + keyboard mic layout due "
                << "to KEYBOARD_MIC effect.";
     } else {
       DVLOG(1) << "KEYBOARD_MIC effect ignored, not compatible with layout "
                << channel_layout;
     }
@@ skipping 45 matching lines @@
     : constraints_(constraints),
       audio_processor_(new rtc::RefCountedObject<MediaStreamAudioProcessor>(
           constraints,
           device_info.device.input.effects,
           audio_device)),
       running_(false),
       render_view_id_(render_view_id),
       device_info_(device_info),
       volume_(0),
       peer_connection_mode_(false),
-      key_pressed_(false),
-      need_audio_processing_(false),
       audio_device_(audio_device),
       audio_source_(audio_source) {
   DVLOG(1) << "WebRtcAudioCapturer::WebRtcAudioCapturer()";
 }
 
 WebRtcAudioCapturer::~WebRtcAudioCapturer() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(tracks_.IsEmpty());
   DVLOG(1) << "WebRtcAudioCapturer::~WebRtcAudioCapturer()";
   Stop();
@@ skipping 76 matching lines @@
   media::AudioParameters params(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
                                 channel_layout, sample_rate,
                                 16, buffer_size,
                                 device_info_.device.input.effects);
 
   {
     base::AutoLock auto_lock(lock_);
     // Notify the |audio_processor_| of the new format.
     audio_processor_->OnCaptureFormatChanged(params);
 
-    MediaAudioConstraints audio_constraints(constraints_,
-                                            device_info_.device.input.effects);
-    need_audio_processing_ = audio_constraints.NeedsAudioProcessing();
     // Notify all tracks about the new format.
     tracks_.TagAll();
   }
 
   if (source.get())
     source->Initialize(params, this, session_id());
 
   Start();
 }
 
@@ skipping 111 matching lines @@
   // allows the user to set a scaling that is higher than 100%. It means that
   // even if the reported maximum levels is N, the actual microphone level can
   // go up to 1.5x*N and that corresponds to a normalized |volume| of 1.5x.
   DCHECK_LE(volume, 1.6);
 #endif
 
   TrackList::ItemList tracks;
   TrackList::ItemList tracks_to_notify_format;
   int current_volume = 0;
   base::TimeDelta audio_delay;
-  bool need_audio_processing = true;
   {
     base::AutoLock auto_lock(lock_);
     if (!running_)
       return;
 
     // Map internal volume range of [0.0, 1.0] into [0, 255] used by AGC.
     // The volume can be higher than 255 on Linux, and it will be cropped to
     // 255 since AGC does not allow values out of range.
     volume_ = static_cast<int>((volume * MaxVolume()) + 0.5);
     current_volume = volume_ > MaxVolume() ? MaxVolume() : volume_;
     audio_delay = base::TimeDelta::FromMilliseconds(audio_delay_milliseconds);
-    audio_delay_ = audio_delay;
-    key_pressed_ = key_pressed;
     tracks = tracks_.Items();
     tracks_.RetrieveAndClearTags(&tracks_to_notify_format);
-
-    // Set the flag to turn on the audio processing in PeerConnection level.
-    // Note that, we turn off the audio processing in PeerConnection if the
-    // processor has already processed the data.
-    need_audio_processing = need_audio_processing_ ?
-        !MediaStreamAudioProcessor::IsAudioTrackProcessingEnabled() : false;
   }
 
   DCHECK(audio_processor_->InputFormat().IsValid());
   DCHECK_EQ(audio_source->channels(),
             audio_processor_->InputFormat().channels());
   DCHECK_EQ(audio_source->frames(),
             audio_processor_->InputFormat().frames_per_buffer());
 
   // Notify the tracks on when the format changes. This will do nothing if
   // |tracks_to_notify_format| is empty.
@@ skipping 15 matching lines @@
 
   // Process and consume the data in the processor until there is not enough
   // data in the processor.
   int16* output = NULL;
   int new_volume = 0;
   while (audio_processor_->ProcessAndConsumeData(
       audio_delay, current_volume, key_pressed, &new_volume, &output)) {
     // Feed the post-processed data to the tracks.
     for (TrackList::ItemList::const_iterator it = tracks.begin();
          it != tracks.end(); ++it) {
-      (*it)->Capture(output, audio_delay, current_volume, key_pressed,
-                     need_audio_processing, force_report_nonzero_energy);
+      (*it)->Capture(output, force_report_nonzero_energy);
     }
 
     if (new_volume) {
       SetVolume(new_volume);
 
       // Update the |current_volume| to avoid passing the old volume to AGC.
       current_volume = new_volume;
     }
   }
 }
@@ skipping 45 matching lines @@
       hardware_buffer_size <= peer_connection_buffer_size &&
       !audio_processor_->has_audio_processing()) {
     DVLOG(1) << "WebRtcAudioCapturer is using hardware buffer size "
              << hardware_buffer_size;
     return hardware_buffer_size;
   }
 
   return (sample_rate / 100);
 }
 
-void WebRtcAudioCapturer::GetAudioProcessingParams(
-    base::TimeDelta* delay, int* volume, bool* key_pressed) {
-  base::AutoLock auto_lock(lock_);
-  *delay = audio_delay_;
-  *volume = volume_;
-  *key_pressed = key_pressed_;
-}
-
 void WebRtcAudioCapturer::SetCapturerSourceForTesting(
     const scoped_refptr<media::AudioCapturerSource>& source,
     media::AudioParameters params) {
   // Create a new audio stream as source which uses the new source.
   SetCapturerSource(source, params.channel_layout(),
                     static_cast<float>(params.sample_rate()));
 }
 
 }  // namespace content