start/stop the source of the capturer when 1st audiotrack/last audiotrack is added/removed

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/string_util.h"
@@ skipping 146 matching lines @@
   // will be overwritten if an external client later calls SetCapturerSource()
   // providing an alternative media::AudioCapturerSource.
   SetCapturerSource(AudioDeviceFactory::NewInputDevice(render_view_id),
                     channel_layout,
                     static_cast<float>(sample_rate));
 
   return true;
 }
 
 WebRtcAudioCapturer::WebRtcAudioCapturer()
-    : source_(NULL),
+    : default_sink_(NULL),
+      source_(NULL),
       running_(false),
       agc_is_enabled_(false),
       session_id_(0) {
   DVLOG(1) << "WebRtcAudioCapturer::WebRtcAudioCapturer()";
 }
 
 WebRtcAudioCapturer::~WebRtcAudioCapturer() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(tracks_.empty());
   DCHECK(!running_);
+  DCHECK(!default_sink_);
   DVLOG(1) << "WebRtcAudioCapturer::~WebRtcAudioCapturer()";
 }
 
-void WebRtcAudioCapturer::AddSink(
-    WebRtcAudioCapturerSink* track) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+void WebRtcAudioCapturer::SetDefaultSink(WebRtcAudioCapturerSink* sink) {
+  DVLOG(1) << "WebRtcAudioCapturer::SetDefaultSink()";
+  if (sink) {
+    DCHECK(!default_sink_);
+    default_sink_ = sink;
+    AddSink(sink);
+  } else {
+    DCHECK(default_sink_);
+    RemoveSink(default_sink_);
+    default_sink_ = NULL;
+  }
+}
+
+void WebRtcAudioCapturer::AddSink(WebRtcAudioCapturerSink* track) {
   DCHECK(track);
   DVLOG(1) << "WebRtcAudioCapturer::AddSink()";
+
+  // Start the source if an audio track is connected to the capturer.
+  // |default_sink_| is not an audio track.
+  if (track != default_sink_)
+    Start();
+
   base::AutoLock auto_lock(lock_);
   // Verify that |track| is not already added to the list.
   DCHECK(std::find_if(
       tracks_.begin(), tracks_.end(),
       WebRtcAudioCapturerSinkOwner::WrapsSink(track)) == tracks_.end());
 
   if (buffer_.get()) {
     track->SetCaptureFormat(buffer_->params());
   } else {
     DLOG(WARNING) << "The format of the capturer has not been correctly "
                   <<  "initialized";
   }
 
   // Create (and add to the list) a new WebRtcAudioCapturerSinkOwner which owns
   // the |track| and delagates all calls to the WebRtcAudioCapturerSink
   // interface.
   tracks_.push_back(new WebRtcAudioCapturerSinkOwner(track));
   // TODO(xians): should we call SetCapturerFormat() to each track?
 }
 
 void WebRtcAudioCapturer::RemoveSink(
     WebRtcAudioCapturerSink* track) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "WebRtcAudioCapturer::RemoveSink()";
 
-  base::AutoLock auto_lock(lock_);
+  bool stop_source = false;
+  {
+    base::AutoLock auto_lock(lock_);
 
-  // Get iterator to the first element for which WrapsSink(track) returns true.
-  TrackList::iterator it = std::find_if(
-      tracks_.begin(), tracks_.end(),
-      WebRtcAudioCapturerSinkOwner::WrapsSink(track));
-  if (it != tracks_.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();
-    tracks_.erase(it);
+    // Get iterator to the first element for which WrapsSink(track) returns
+    // true.
+    TrackList::iterator it = std::find_if(
+        tracks_.begin(), tracks_.end(),
+        WebRtcAudioCapturerSinkOwner::WrapsSink(track));
+    if (it != tracks_.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();
+      tracks_.erase(it);
+    }
+
+    // Stop the source if the last audio track is going away.
+    // The |tracks_| might contain the |default_sink_|, we need to stop the
+    // source if the only remaining element is |default_sink_|.
+    if (tracks_.size() == 1 && default_sink_ &&
+        (*tracks_.begin())->IsEqual(default_sink_)) {
+      stop_source = true;
+    } else {
+      // The source might have been stopped, but it is safe to call Stop()
+      // again to make sure the source is stopped correctly.
+      stop_source = tracks_.empty();
+    }
   }
+
+  if (stop_source)
+    Stop();
 }
 
 void WebRtcAudioCapturer::SetCapturerSource(
     const scoped_refptr<media::AudioCapturerSource>& source,
     media::ChannelLayout channel_layout,
     float sample_rate) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "SetCapturerSource(channel_layout=" << channel_layout << ","
            << "sample_rate=" << sample_rate << ")";
   scoped_refptr<media::AudioCapturerSource> old_source;
@@ skipping 133 matching lines @@
 }
 
 media::AudioParameters WebRtcAudioCapturer::audio_parameters() const {
   base::AutoLock auto_lock(lock_);
   // |buffer_| can be NULL when SetCapturerSource() or Initialize() has not
   // been called.
   return buffer_.get() ? buffer_->params() : media::AudioParameters();
 }
 
 }  // namespace content