Add generic interfaces for the sinks of the media stream audio track

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_sink_owner.h"
 #include "content/renderer/media/webaudio_capturer_source.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
-#include "content/renderer/media/webrtc_audio_capturer_sink_owner.h"
+#include "content/renderer/media/webrtc_audio_device_impl.h"
 #include "content/renderer/media/webrtc_local_audio_source_provider.h"
 #include "media/base/audio_fifo.h"
 #include "third_party/libjingle/source/talk/media/base/audiorenderer.h"
 
 namespace content {
 
 static const size_t kMaxNumberOfBuffersInFifo = 2;
 static const char kAudioTrackKind[] = "audio";
 
 namespace {
@@ skipping 152 matching lines @@
     voe_channels = voe_channels_;
     sinks = sinks_;
     std::swap(sinks_to_notify_format_, sinks_to_notify_format);
     is_webaudio_source = (webaudio_source_.get() != NULL);
   }
 
   // Notify the tracks on when the format changes. This will do nothing if
   // |sinks_to_notify_format| is empty.
   for (SinkList::const_iterator it = sinks_to_notify_format.begin();
        it != sinks_to_notify_format.end(); ++it) {
-    (*it)->SetCaptureFormat(buffer_->params());
+    (*it)->OnSetFormat(buffer_->params());
   }
 
   // Push the data to the fifo.
   buffer_->Push(audio_source);
 
   // When the source is WebAudio, turn off the audio processing if the delay
   // value is 0 even though the constraint is set to true. In such case, it
   // indicates the data is not from microphone.
   // TODO(xians): remove the flag when supporting one APM per audio track.
   // See crbug/264611 for details.
   bool need_audio_processing = need_audio_processing_;
   if (is_webaudio_source && need_audio_processing)
     need_audio_processing = (audio_delay_milliseconds != 0);
 
   int current_volume = volume;
   while (buffer_->Consume()) {
     // 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.
     for (SinkList::const_iterator it = sinks.begin(); it != sinks.end(); ++it) {
-      int new_volume = (*it)->CaptureData(voe_channels,
-                                          buffer_->buffer(),
-                                          buffer_->params().sample_rate(),
-                                          buffer_->params().channels(),
-                                          buffer_->params().frames_per_buffer(),
-                                          audio_delay_milliseconds,
-                                          current_volume,
-                                          need_audio_processing,
-                                          key_pressed);
+      int new_volume = (*it)->OnData(buffer_->buffer(),
+                                     buffer_->params().sample_rate(),
+                                     buffer_->params().channels(),
+                                     buffer_->params().frames_per_buffer(),
+                                     voe_channels,
+                                     audio_delay_milliseconds,
+                                     current_volume,
+                                     need_audio_processing,
+                                     key_pressed);
       if (new_volume != 0 && capturer.get()) {
         // Feed the new volume to WebRtc while changing the volume on the
         // browser.
         capturer->SetVolume(new_volume);
         current_volume = new_volume;
       }
     }
   }
 }
 
-void WebRtcLocalAudioTrack::SetCaptureFormat(
+void WebRtcLocalAudioTrack::OnSetFormat(
     const media::AudioParameters& params) {
-  DVLOG(1) << "WebRtcLocalAudioTrack::SetCaptureFormat()";
+  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());
 
   DCHECK(params.IsValid());
   buffer_->Configure(params);
 
   base::AutoLock auto_lock(lock_);
   // Copy |sinks_| to |sinks_to_notify_format_| to notify all the sinks
@@ skipping 31 matching lines @@
 }
 
 cricket::AudioRenderer* WebRtcLocalAudioTrack::GetRenderer() {
   return this;
 }
 
 std::string WebRtcLocalAudioTrack::kind() const {
   return kAudioTrackKind;
 }
 
-void WebRtcLocalAudioTrack::AddSink(WebRtcAudioCapturerSink* sink) {
+void WebRtcLocalAudioTrack::AddSink(MediaStreamAudioSink* 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(std::find_if(
       sinks_.begin(), sinks_.end(),
-      WebRtcAudioCapturerSinkOwner::WrapsSink(sink)) == sinks_.end());
+      MediaStreamAudioSinkOwner::WrapsSink(sink)) == sinks_.end());
 
-  // Create (and add to the list) a new WebRtcAudioCapturerSinkOwner which owns
-  // the |sink| and delagates all calls to the WebRtcAudioCapturerSink
+  // Create (and add to the list) a new MediaStreamAudioSinkOwner which owns
+  // the |sink| and delagates all calls to the MediaStreamAudioSink
   // interface.
-  scoped_refptr<WebRtcAudioCapturerSinkOwner> sink_owner(
-      new WebRtcAudioCapturerSinkOwner(sink));
+  scoped_refptr<MediaStreamAudioSinkOwner> sink_owner(
+      new MediaStreamAudioSinkOwner(sink));
   sinks_.push_back(sink_owner);
 
   // Also push the |sink_owner| to |sinks_to_notify_format_| so that we will
-  // call SetCaptureFormat() on the new sink.
+  // call OnSetFormat() on the new sink.
   sinks_to_notify_format_.push_back(sink_owner);
 }
 
-void WebRtcLocalAudioTrack::RemoveSink(
-    WebRtcAudioCapturerSink* sink) {
+void WebRtcLocalAudioTrack::RemoveSink(MediaStreamAudioSink* sink) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DVLOG(1) << "WebRtcLocalAudioTrack::RemoveSink()";
 
   base::AutoLock auto_lock(lock_);
   // Remove the item on |tracks_to_notify_format_|.
   // This has to be done before remove the element in |sinks_| since there it
   // will clear the delegate.
   SinkList::iterator it = std::find_if(
       sinks_to_notify_format_.begin(), sinks_to_notify_format_.end(),
-      WebRtcAudioCapturerSinkOwner::WrapsSink(sink));
+      MediaStreamAudioSinkOwner::WrapsSink(sink));
   if (it != sinks_to_notify_format_.end())
     sinks_to_notify_format_.erase(it);
 
   // Get iterator to the first element for which WrapsSink(sink) returns true.
   it = std::find_if(sinks_.begin(), sinks_.end(),
-                    WebRtcAudioCapturerSinkOwner::WrapsSink(sink));
+                    MediaStreamAudioSinkOwner::WrapsSink(sink));
   if (it != sinks_.end()) {
     // 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.
+    (*it)->Reset();
+    sinks_.erase(it);
+  }
+}
+
+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(std::find_if(
+      sinks_.begin(), sinks_.end(),
+      MediaStreamAudioSinkOwner::WrapsPeerConnectionSink(sink)) ==
+          sinks_.end());
+
+  // Create (and add to the list) a new MediaStreamAudioSinkOwner which owns
+  // the |sink| and delagates all calls to the MediaStreamAudioSink
+  // interface.
+  scoped_refptr<MediaStreamAudioSinkOwner> sink_owner(
+      new MediaStreamAudioSinkOwner(sink));
+  sinks_.push_back(sink_owner);
+
+  // Also push the |sink_owner| to |sinks_to_notify_format_| so that we will
+  // call OnSetFormat() on the new sink.
+  sinks_to_notify_format_.push_back(sink_owner);
+}
+
+void WebRtcLocalAudioTrack::RemoveSink(PeerConnectionAudioSink* sink) {
+  DCHECK(main_render_thread_checker_.CalledOnValidThread());
+  DVLOG(1) << "WebRtcLocalAudioTrack::RemoveSink()";
+
+  base::AutoLock auto_lock(lock_);
+  // Remove the item on |tracks_to_notify_format_|.
+  // This has to be done before remove the element in |sinks_| since there it
+  // will clear the delegate.
+  SinkList::iterator it = std::find_if(
+      sinks_to_notify_format_.begin(), sinks_to_notify_format_.end(),
+      MediaStreamAudioSinkOwner::WrapsPeerConnectionSink(sink));
+  if (it != sinks_to_notify_format_.end())
+    sinks_to_notify_format_.erase(it);
+
+  // Get iterator to the first element for which WrapsPeerConnectionSink(sink)
+  // returns true.
+  it = std::find_if(sinks_.begin(), sinks_.end(),
+                    MediaStreamAudioSinkOwner::WrapsPeerConnectionSink(sink));
+  if (it != sinks_.end()) {
+    // 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.
     (*it)->Reset();
     sinks_.erase(it);
   }
 }
 
 void WebRtcLocalAudioTrack::Start() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DVLOG(1) << "WebRtcLocalAudioTrack::Start()";
   if (webaudio_source_.get()) {
@@ skipping 35 matching lines @@
     sinks_to_notify_format_.clear();
     webaudio_source_ = NULL;
     capturer_ = NULL;
   }
 
   for (SinkList::const_iterator it = sinks.begin(); it != sinks.end(); ++it)
     (*it)->Reset();
 }
 
 }  // namespace content