Revert of 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";
 
-  {
-    base::AutoLock auto_lock(lock_);
-    capturers_.clear();
+  // 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();
   }
 
   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.
-  base::AutoLock auto_lock(lock_);
-  if (capturers_.empty())
+  scoped_refptr<WebRtcAudioCapturer> capturer(GetDefaultCapturer());
+  if (!capturer.get())
     return -1;
-  capturers_.back()->SetVolume(volume);
+
+  capturer->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_);
-  base::AutoLock auto_lock(lock_);
-  if (capturers_.empty())
+  scoped_refptr<WebRtcAudioCapturer> capturer(GetDefaultCapturer());
+  if (!capturer.get())
     return -1;
-  *volume = static_cast<uint32_t>(capturers_.back()->Volume());
+
+  *volume = static_cast<uint32_t>(capturer->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.
-  base::AutoLock auto_lock(lock_);
-  if (capturers_.empty())
+  scoped_refptr<WebRtcAudioCapturer> capturer(GetDefaultCapturer());
+  if (!capturer.get())
     return -1;
-  *available = (capturers_.back()->GetInputFormat().channels() == 2);
+
+  *available = (capturer->source_audio_parameters().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.
-  base::AutoLock auto_lock(lock_);
-  if (capturers_.empty())
+  scoped_refptr<WebRtcAudioCapturer> capturer(GetDefaultCapturer());
+  if (!capturer.get())
     return -1;
-  const media::AudioParameters& params = capturers_.back()->GetInputFormat();
-  *sample_rate = static_cast<uint32_t>(params.sample_rate());
+
+  *sample_rate = static_cast<uint32_t>(
+      capturer->source_audio_parameters().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(WebRtcAudioCapturer* capturer) {
+void WebRtcAudioDeviceImpl::AddAudioCapturer(
+    const scoped_refptr<WebRtcAudioCapturer>& capturer) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DVLOG(1) << "WebRtcAudioDeviceImpl::AddAudioCapturer()";
-  DCHECK(capturer);
-  DCHECK(!capturer->device_info().device.id.empty());
+  DCHECK(capturer.get());
+  DCHECK(!capturer->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(WebRtcAudioCapturer* capturer) {
+void WebRtcAudioDeviceImpl::RemoveAudioCapturer(
+    const scoped_refptr<WebRtcAudioCapturer>& capturer) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
-  DVLOG(1) << "WebRtcAudioDeviceImpl::RemoveAudioCapturer()";
-  DCHECK(capturer);
+  DVLOG(1) << "WebRtcAudioDeviceImpl::AddAudioCapturer()";
+  DCHECK(capturer.get());
   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;
 
-  // 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;
+  return capturers_.back()->GetPairedOutputParameters(
+      session_id, output_sample_rate, output_frames_per_buffer);
 }
 
 }  // namespace content