MediaStream audio object graph untangling and clean-ups.

content/renderer/media/webrtc_audio_device_impl.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/webrtc_audio_device_impl.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/win/windows_version.h"
@@ skipping 152 matching lines @@
   // Calling Terminate() multiple times in a row is OK.
   if (!initialized_)
     return 0;
 
   StopRecording();
   StopPlayout();
 
   DCHECK(!renderer_.get() || !renderer_->IsStarted())
       << "The shared audio renderer shouldn't be running";
 
-  // Stop all the capturers to ensure no further OnData() and
-  // RemoveAudioCapturer() callback.
-  // Cache the capturers in a local list since WebRtcAudioCapturer::Stop()
-  // will trigger RemoveAudioCapturer() callback.
-  CapturerList capturers;
-  capturers.swap(capturers_);
-  for (CapturerList::const_iterator iter = capturers.begin();
-       iter != capturers.end(); ++iter) {
-    (*iter)->Stop();
+  {
+    base::AutoLock auto_lock(lock_);
+    capturers_.clear();
   }
 
   initialized_ = false;
   return 0;
 }
 
 bool WebRtcAudioDeviceImpl::Initialized() const {
   DCHECK(signaling_thread_checker_.CalledOnValidThread());
   return initialized_;
 }
@@ skipping 95 matching lines @@
   return recording_;
 }
 
 int32_t WebRtcAudioDeviceImpl::SetMicrophoneVolume(uint32_t volume) {
   DVLOG(1) << "WebRtcAudioDeviceImpl::SetMicrophoneVolume(" << volume << ")";
   DCHECK(signaling_thread_checker_.CalledOnValidThread());
   DCHECK(initialized_);
 
   // Only one microphone is supported at the moment, which is represented by
   // the default capturer.
-  scoped_refptr<WebRtcAudioCapturer> capturer(GetDefaultCapturer());
-  if (!capturer.get())
+  base::AutoLock auto_lock(lock_);
+  if (capturers_.empty())
     return -1;
-
-  capturer->SetVolume(volume);
+  capturers_.back()->SetVolume(volume);
   return 0;
 }
 
 // TODO(henrika): sort out calling thread once we start using this API.
 int32_t WebRtcAudioDeviceImpl::MicrophoneVolume(uint32_t* volume) const {
   DVLOG(1) << "WebRtcAudioDeviceImpl::MicrophoneVolume()";
   DCHECK(signaling_thread_checker_.CalledOnValidThread());
   // We only support one microphone now, which is accessed via the default
   // capturer.
   DCHECK(initialized_);
-  scoped_refptr<WebRtcAudioCapturer> capturer(GetDefaultCapturer());
-  if (!capturer.get())
+  base::AutoLock auto_lock(lock_);
+  if (capturers_.empty())
     return -1;
-
-  *volume = static_cast<uint32_t>(capturer->Volume());
-
+  *volume = static_cast<uint32_t>(capturers_.back()->Volume());
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::MaxMicrophoneVolume(uint32_t* max_volume) const {
   DCHECK(initialized_);
   DCHECK(signaling_thread_checker_.CalledOnValidThread());
   *max_volume = kMaxVolumeLevel;
   return 0;
 }
 
@@ skipping 17 matching lines @@
 int32_t WebRtcAudioDeviceImpl::StereoRecordingIsAvailable(
     bool* available) const {
   DCHECK(initialized_);
   // This method is called during initialization on the signaling thread and
   // then later on the worker thread.  Due to this we cannot DCHECK on what
   // thread we're on since it might incorrectly initialize the
   // worker_thread_checker_.
 
   // TODO(xians): These kind of hardware methods do not make much sense since we
   // support multiple sources. Remove or figure out new APIs for such methods.
-  scoped_refptr<WebRtcAudioCapturer> capturer(GetDefaultCapturer());
-  if (!capturer.get())
+  base::AutoLock auto_lock(lock_);
+  if (capturers_.empty())
     return -1;
-
-  *available = (capturer->source_audio_parameters().channels() == 2);
+  *available = (capturers_.back()->GetInputFormat().channels() == 2);
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::PlayoutDelay(uint16_t* delay_ms) const {
   DCHECK(worker_thread_checker_.CalledOnValidThread());
   base::AutoLock auto_lock(lock_);
   *delay_ms = static_cast<uint16_t>(output_delay_ms_);
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::RecordingDelay(uint16_t* delay_ms) const {
   DCHECK(signaling_thread_checker_.CalledOnValidThread());
 
   // There is no way to report a correct delay value to WebRTC since there
   // might be multiple WebRtcAudioCapturer instances.
   NOTREACHED();
   return -1;
 }
 
 int32_t WebRtcAudioDeviceImpl::RecordingSampleRate(
     uint32_t* sample_rate) const {
   DCHECK(signaling_thread_checker_.CalledOnValidThread());
   // We use the default capturer as the recording sample rate.
-  scoped_refptr<WebRtcAudioCapturer> capturer(GetDefaultCapturer());
-  if (!capturer.get())
+  base::AutoLock auto_lock(lock_);
+  if (capturers_.empty())
     return -1;
-
-  *sample_rate = static_cast<uint32_t>(
-      capturer->source_audio_parameters().sample_rate());
+  const media::AudioParameters& params = capturers_.back()->GetInputFormat();
+  *sample_rate = static_cast<uint32_t>(params.sample_rate());
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::PlayoutSampleRate(
     uint32_t* sample_rate) const {
   DCHECK(signaling_thread_checker_.CalledOnValidThread());
   *sample_rate = renderer_.get() ? renderer_->sample_rate() : 0;
   return 0;
 }
 
@@ skipping 27 matching lines @@
   audio_renderer_thread_checker_.DetachFromThread();
 
   // We acquire |lock_| again and assert our precondition, since we are
   // accessing the internal state again.
   base::AutoLock auto_lock(lock_);
   DCHECK(!renderer_.get());
   renderer_ = renderer;
   return true;
 }
 
-void WebRtcAudioDeviceImpl::AddAudioCapturer(
-    const scoped_refptr<WebRtcAudioCapturer>& capturer) {
+void WebRtcAudioDeviceImpl::AddAudioCapturer(WebRtcAudioCapturer* capturer) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DVLOG(1) << "WebRtcAudioDeviceImpl::AddAudioCapturer()";
-  DCHECK(capturer.get());
-  DCHECK(!capturer->device_id().empty());
+  DCHECK(capturer);
+  DCHECK(!capturer->device_info().device.id.empty());
 
   base::AutoLock auto_lock(lock_);
   DCHECK(std::find(capturers_.begin(), capturers_.end(), capturer) ==
       capturers_.end());
   capturers_.push_back(capturer);
 }
 
-void WebRtcAudioDeviceImpl::RemoveAudioCapturer(
-    const scoped_refptr<WebRtcAudioCapturer>& capturer) {
+void WebRtcAudioDeviceImpl::RemoveAudioCapturer(WebRtcAudioCapturer* capturer) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
-  DVLOG(1) << "WebRtcAudioDeviceImpl::AddAudioCapturer()";
-  DCHECK(capturer.get());
+  DVLOG(1) << "WebRtcAudioDeviceImpl::RemoveAudioCapturer()";
+  DCHECK(capturer);
   base::AutoLock auto_lock(lock_);
   capturers_.remove(capturer);
 }
 
-scoped_refptr<WebRtcAudioCapturer>
-WebRtcAudioDeviceImpl::GetDefaultCapturer() const {
-  // Called on the signaling thread (during initialization), worker
-  // thread during capture or main thread for a WebAudio source.
-  // We can't DCHECK on those three checks here since GetDefaultCapturer
-  // may be the first call and therefore could incorrectly initialize the
-  // thread checkers.
-  DCHECK(initialized_);
-  base::AutoLock auto_lock(lock_);
-  // Use the last |capturer| which is from the latest getUserMedia call as
-  // the default capture device.
-  return capturers_.empty() ? NULL : capturers_.back();
-}
-
 void WebRtcAudioDeviceImpl::AddPlayoutSink(
     WebRtcPlayoutDataSource::Sink* sink) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(sink);
   base::AutoLock auto_lock(lock_);
   DCHECK(std::find(playout_sinks_.begin(), playout_sinks_.end(), sink) ==
       playout_sinks_.end());
   playout_sinks_.push_back(sink);
 }
 
 void WebRtcAudioDeviceImpl::RemovePlayoutSink(
     WebRtcPlayoutDataSource::Sink* sink) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(sink);
   base::AutoLock auto_lock(lock_);
   playout_sinks_.remove(sink);
 }
 
 bool WebRtcAudioDeviceImpl::GetAuthorizedDeviceInfoForAudioRenderer(
     int* session_id,
     int* output_sample_rate,
     int* output_frames_per_buffer) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   base::AutoLock lock(lock_);
   // If there is no capturer or there are more than one open capture devices,
   // return false.
   if (capturers_.size() != 1)
     return false;
 
-  return capturers_.back()->GetPairedOutputParameters(
-      session_id, output_sample_rate, output_frames_per_buffer);
+  // Don't set output parameters unless all of them are valid.
+  const StreamDeviceInfo& device_info = capturers_.back()->device_info();
+  if (device_info.session_id <= 0 ||
+      !device_info.device.matched_output.sample_rate ||
+      !device_info.device.matched_output.frames_per_buffer)
+    return false;
+
+  *session_id = device_info.session_id;
+  *output_sample_rate = device_info.device.matched_output.sample_rate;
+  *output_frames_per_buffer =
+      device_info.device.matched_output.frames_per_buffer;
+
+  return true;
 }
 
 }  // namespace content