Clean up the media stream audio track code

content/renderer/media/webrtc_local_audio_track.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_local_audio_track.h"
 
 #include "content/public/renderer/media_stream_audio_sink.h"
 #include "content/renderer/media/media_stream_audio_level_calculator.h"
 #include "content/renderer/media/media_stream_audio_processor.h"
 #include "content/renderer/media/media_stream_audio_sink_owner.h"
 #include "content/renderer/media/media_stream_audio_track_sink.h"
-#include "content/renderer/media/peer_connection_audio_sink_owner.h"
 #include "content/renderer/media/webaudio_capturer_source.h"
 #include "content/renderer/media/webrtc/webrtc_local_audio_track_adapter.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
 
 namespace content {
 
 WebRtcLocalAudioTrack::WebRtcLocalAudioTrack(
     WebRtcLocalAudioTrackAdapter* adapter,
     const scoped_refptr<WebRtcAudioCapturer>& capturer,
     WebAudioCapturerSource* webaudio_source)
     : MediaStreamTrack(adapter, true),
       adapter_(adapter),
       capturer_(capturer),
       webaudio_source_(webaudio_source) {
   DCHECK(capturer.get() || webaudio_source);
 
   adapter_->Initialize(this);
 
   DVLOG(1) << "WebRtcLocalAudioTrack::WebRtcLocalAudioTrack()";
 }
 
 WebRtcLocalAudioTrack::~WebRtcLocalAudioTrack() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DVLOG(1) << "WebRtcLocalAudioTrack::~WebRtcLocalAudioTrack()";
   // Users might not call Stop() on the track.
   Stop();
 }
 
 void WebRtcLocalAudioTrack::Capture(const int16* audio_data,
-                                    base::TimeDelta delay,
-                                    int volume,
-                                    bool key_pressed,
-                                    bool need_audio_processing,
                                     bool force_report_nonzero_energy) {
   DCHECK(capture_thread_checker_.CalledOnValidThread());
 
   // Calculate the signal level regardless if the track is disabled or enabled.
   int signal_level = level_calculator_->Calculate(
       audio_data, audio_parameters_.channels(),
       audio_parameters_.frames_per_buffer(), force_report_nonzero_energy);
   adapter_->SetSignalLevel(signal_level);
 
   scoped_refptr<WebRtcAudioCapturer> capturer;
@@ skipping 15 matching lines @@
 
   // Feed the data to the sinks.
   // TODO(jiayl): we should not pass the real audio data down if the track is
   // disabled. This is currently done so to feed input to WebRTC typing
   // detection and should be changed when audio processing is moved from
   // WebRTC to the track.
   std::vector<int> voe_channels = adapter_->VoeChannels();
   for (SinkList::ItemList::const_iterator it = sinks.begin();
        it != sinks.end();
        ++it) {
-    int new_volume = (*it)->OnData(audio_data,
-                                   audio_parameters_.sample_rate(),
-                                   audio_parameters_.channels(),
-                                   audio_parameters_.frames_per_buffer(),
-                                   voe_channels,
-                                   delay.InMilliseconds(),
-                                   volume,
-                                   need_audio_processing,
-                                   key_pressed);
-    if (new_volume != 0 && capturer.get() && !webaudio_source_.get()) {
-      // Feed the new volume to WebRtc while changing the volume on the
-      // browser.
-      capturer->SetVolume(new_volume);
-    }
+    (*it)->OnData(audio_data, audio_parameters_.sample_rate(),
+                  audio_parameters_.channels(),
+                  audio_parameters_.frames_per_buffer());
   }
 }
 
 void WebRtcLocalAudioTrack::OnSetFormat(
     const media::AudioParameters& params) {
   DVLOG(1) << "WebRtcLocalAudioTrack::OnSetFormat()";
   // If the source is restarted, we might have changed to another capture
   // thread.
   capture_thread_checker_.DetachFromThread();
   DCHECK(capture_thread_checker_.CalledOnValidThread());
@@ skipping 43 matching lines @@
   scoped_refptr<MediaStreamAudioTrackSink> removed_item = sinks_.Remove(
       MediaStreamAudioTrackSink::WrapsMediaStreamSink(sink));
 
   // Clear the delegate to ensure that no more capture callbacks will
   // be sent to this sink. Also avoids a possible crash which can happen
   // if this method is called while capturing is active.
   if (removed_item.get())
     removed_item->Reset();
 }
 
-void WebRtcLocalAudioTrack::AddSink(PeerConnectionAudioSink* sink) {
-  DCHECK(main_render_thread_checker_.CalledOnValidThread());
-  DVLOG(1) << "WebRtcLocalAudioTrack::AddSink()";
-  base::AutoLock auto_lock(lock_);
-
-  // Verify that |sink| is not already added to the list.
-  DCHECK(!sinks_.Contains(
-      MediaStreamAudioTrackSink::WrapsPeerConnectionSink(sink)));
-
-  // Create (and add to the list) a new MediaStreamAudioTrackSink
-  // which owns the |sink| and delagates all calls to the
-  // MediaStreamAudioSink interface. It will be tagged in the list, so
-  // we remember to call OnSetFormat() on the new sink.
-  scoped_refptr<MediaStreamAudioTrackSink> sink_owner(
-      new PeerConnectionAudioSinkOwner(sink));
-  sinks_.AddAndTag(sink_owner.get());
-}
-
-void WebRtcLocalAudioTrack::RemoveSink(PeerConnectionAudioSink* sink) {
-  DCHECK(main_render_thread_checker_.CalledOnValidThread());
-  DVLOG(1) << "WebRtcLocalAudioTrack::RemoveSink()";
-
-  base::AutoLock auto_lock(lock_);
-
-  scoped_refptr<MediaStreamAudioTrackSink> removed_item = sinks_.Remove(
-      MediaStreamAudioTrackSink::WrapsPeerConnectionSink(sink));
-  // Clear the delegate to ensure that no more capture callbacks will
-  // be sent to this sink. Also avoids a possible crash which can happen
-  // if this method is called while capturing is active.
-  if (removed_item.get())
-    removed_item->Reset();
-}
-
 void WebRtcLocalAudioTrack::Start() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DVLOG(1) << "WebRtcLocalAudioTrack::Start()";
   if (webaudio_source_.get()) {
     // If the track is hooking up with WebAudio, do NOT add the track to the
     // capturer as its sink otherwise two streams in different clock will be
     // pushed through the same track.
-    webaudio_source_->Start(this, capturer_.get());
+    webaudio_source_->Start(this);
   } else if (capturer_.get()) {
     capturer_->AddTrack(this);
   }
 
   SinkList::ItemList sinks;
   {
     base::AutoLock auto_lock(lock_);
     sinks = sinks_.Items();
   }
   for (SinkList::ItemList::const_iterator it = sinks.begin();
@@ skipping 34 matching lines @@
 
   for (SinkList::ItemList::const_iterator it = sinks.begin();
        it != sinks.end();
        ++it){
     (*it)->OnReadyStateChanged(blink::WebMediaStreamSource::ReadyStateEnded);
     (*it)->Reset();
   }
 }
 
 }  // namespace content