Reland 15721002: Hook up the device selection to the WebAudio live audio

media/audio/audio_manager_base.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 "media/audio/audio_manager_base.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop_proxy.h"
 #include "base/threading/thread.h"
@@ skipping 14 matching lines @@
 
 // Default maximum number of input streams that can be open simultaneously
 // for all platforms.
 static const int kDefaultMaxInputStreams = 16;
 
 static const int kMaxInputChannels = 2;
 
 const char AudioManagerBase::kDefaultDeviceName[] = "Default";
 const char AudioManagerBase::kDefaultDeviceId[] = "default";
 
+struct AudioManagerBase::DispatcherParams {
+  DispatcherParams(const AudioParameters& input,
+                   const AudioParameters& output,
+                   const std::string& device_id)
+      : input_params(input),
+        output_params(output),
+        input_device_id(device_id) {}
+  ~DispatcherParams() {}
+
+  const AudioParameters input_params;
+  const AudioParameters output_params;
+  const std::string input_device_id;
+  scoped_refptr<AudioOutputDispatcher> dispatcher;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DispatcherParams);
+};
+
+class AudioManagerBase::CompareByParams {
+ public:
+  explicit CompareByParams(const DispatcherParams* dispatcher)
+      : dispatcher_(dispatcher) {}
+  bool operator()(DispatcherParams* dispatcher_in) const {
+    // We will reuse the existing dispatcher when:
+    // 1) Unified IO is not used, input_params and output_params of the
+    //    existing dispatcher are the same as the requested dispatcher.
+    // 2) Unified IO is used, input_params, output_params and input_device_id
+    //    of the existing dispatcher are the same as the request dispatcher.
+    return (dispatcher_->input_params == dispatcher_in->input_params &&
+            dispatcher_->output_params == dispatcher_in->output_params &&
+            (!dispatcher_->input_params.input_channels() ||
+             dispatcher_->input_device_id == dispatcher_in->input_device_id));
+  }
+
+ private:
+  const DispatcherParams* dispatcher_;
+};
+
 AudioManagerBase::AudioManagerBase()
     : num_active_input_streams_(0),
       max_num_output_streams_(kDefaultMaxOutputStreams),
       max_num_input_streams_(kDefaultMaxInputStreams),
       num_output_streams_(0),
       num_input_streams_(0),
       output_listeners_(
           ObserverList<AudioDeviceListener>::NOTIFY_EXISTING_ONLY),
       audio_thread_(new base::Thread("AudioThread")) {
 #if defined(OS_WIN)
@@ skipping 25 matching lines @@
 
 string16 AudioManagerBase::GetAudioInputDeviceModel() {
   return string16();
 }
 
 scoped_refptr<base::MessageLoopProxy> AudioManagerBase::GetMessageLoop() {
   return message_loop_;
 }
 
 AudioOutputStream* AudioManagerBase::MakeAudioOutputStream(
-    const AudioParameters& params) {
+    const AudioParameters& params,
+    const std::string& input_device_id) {
   // TODO(miu): Fix ~50 call points across several unit test modules to call
   // this method on the audio thread, then uncomment the following:
   // DCHECK(message_loop_->BelongsToCurrentThread());
 
   if (!params.IsValid()) {
     DLOG(ERROR) << "Audio parameters are invalid";
     return NULL;
   }
 
   // Limit the number of audio streams opened. This is to prevent using
   // excessive resources for a large number of audio streams. More
   // importantly it prevents instability on certain systems.
   // See bug: http://crbug.com/30242.
   if (num_output_streams_ >= max_num_output_streams_) {
     DLOG(ERROR) << "Number of opened output audio streams "
                 << num_output_streams_
                 << " exceed the max allowed number "
                 << max_num_output_streams_;
     return NULL;
   }
 
   AudioOutputStream* stream;
   switch (params.format()) {
     case AudioParameters::AUDIO_PCM_LINEAR:
       stream = MakeLinearOutputStream(params);
       break;
     case AudioParameters::AUDIO_PCM_LOW_LATENCY:
-      stream = MakeLowLatencyOutputStream(params);
+      stream = MakeLowLatencyOutputStream(params, input_device_id);
       break;
     case AudioParameters::AUDIO_FAKE:
       stream = FakeAudioOutputStream::MakeFakeStream(this, params);
       break;
     default:
       stream = NULL;
       break;
   }
 
   if (stream) {
@@ skipping 39 matching lines @@
   }
 
   if (stream) {
     ++num_input_streams_;
   }
 
   return stream;
 }
 
 AudioOutputStream* AudioManagerBase::MakeAudioOutputStreamProxy(
-    const AudioParameters& params) {
+    const AudioParameters& params, const std::string& input_device_id) {
 #if defined(OS_IOS)
   // IOS implements audio input only.
   NOTIMPLEMENTED();
   return NULL;
 #else
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // If we're not using AudioOutputResampler our output parameters are the same
   // as our input parameters.
   AudioParameters output_params = params;
@@ skipping 13 matching lines @@
                  << output_params.frames_per_buffer();
 
       // Tell the AudioManager to create a fake output device.
       output_params = AudioParameters(
           AudioParameters::AUDIO_FAKE, params.channel_layout(),
           params.sample_rate(), params.bits_per_sample(),
           params.frames_per_buffer());
     }
   }
 
-  std::pair<AudioParameters, AudioParameters> dispatcher_key =
-      std::make_pair(params, output_params);
-  AudioOutputDispatchersMap::iterator it =
-      output_dispatchers_.find(dispatcher_key);
-  if (it != output_dispatchers_.end())
-    return new AudioOutputProxy(it->second.get());
+  DispatcherParams* dispatcher_params =
+      new DispatcherParams(params, output_params, input_device_id);
+
+  AudioOutputDispatchers::iterator it =
+      std::find_if(output_dispatchers_.begin(), output_dispatchers_.end(),
+                   CompareByParams(dispatcher_params));
+  if (it != output_dispatchers_.end()) {
+    delete dispatcher_params;
+    return new AudioOutputProxy((*it)->dispatcher);
+  }
 
   const base::TimeDelta kCloseDelay =
       base::TimeDelta::FromSeconds(kStreamCloseDelaySeconds);
 
   if (output_params.format() != AudioParameters::AUDIO_FAKE) {
     scoped_refptr<AudioOutputDispatcher> dispatcher =
-        new AudioOutputResampler(this, params, output_params, kCloseDelay);
-    output_dispatchers_[dispatcher_key] = dispatcher;
+        new AudioOutputResampler(this, params, output_params, input_device_id,
+                                 kCloseDelay);
+    dispatcher_params->dispatcher = dispatcher;
     return new AudioOutputProxy(dispatcher.get());

[Jeffrey Yasskin, 2013/08/07 23:00:47]

This leaks the dispatcher_params. What did you mean to do with that object?

You should also add a direct test of this code path so that we'd find the leak
faster. I saw it in
http://build.chromium.org/p/chromium.memory.fyi/builders/Webkit%20Linux%20%28...,
but it doesn't look reliable there.

[no longer working on chromium, 2013/08/08 08:35:00]

Oh, thanks for finding it out, I am making a CL to fix it now.
We do have tests for this MakeAudioOutputStreamProxy() API, but the reason why
they don't exercise the piece code is that we use AUDIO_FAKE stream on our bots,
in order to avoid opening real hardware devices.

   }
 
   scoped_refptr<AudioOutputDispatcher> dispatcher =
-      new AudioOutputDispatcherImpl(this, output_params, kCloseDelay);
-  output_dispatchers_[dispatcher_key] = dispatcher;
+      new AudioOutputDispatcherImpl(this, output_params, input_device_id,
+                                    kCloseDelay);
+  dispatcher_params->dispatcher = dispatcher;
+  output_dispatchers_.push_back(dispatcher_params);
   return new AudioOutputProxy(dispatcher.get());
 #endif  // defined(OS_IOS)
 }
 
 void AudioManagerBase::ShowAudioInputSettings() {
 }
 
 void AudioManagerBase::GetAudioInputDeviceNames(
     media::AudioDeviceNames* device_names) {
 }
@@ skipping 53 matching lines @@
 
 void AudioManagerBase::ShutdownOnAudioThread() {
 // IOS implements audio input only.
 #if defined(OS_IOS)
   return;
 #else
   // This should always be running on the audio thread, but since we've cleared
   // the audio_thread_ member pointer when we get here, we can't verify exactly
   // what thread we're running on.  The method is not public though and only
   // called from one place, so we'll leave it at that.
-  AudioOutputDispatchersMap::iterator it = output_dispatchers_.begin();
+  AudioOutputDispatchers::iterator it = output_dispatchers_.begin();
   for (; it != output_dispatchers_.end(); ++it) {
-    scoped_refptr<AudioOutputDispatcher>& dispatcher = (*it).second;
+    scoped_refptr<AudioOutputDispatcher>& dispatcher = (*it)->dispatcher;
     if (dispatcher.get()) {
       dispatcher->Shutdown();
       // All AudioOutputProxies must have been freed before Shutdown is called.
       // If they still exist, things will go bad.  They have direct pointers to
       // both physical audio stream objects that belong to the dispatcher as
       // well as the message loop of the audio thread that will soon go away.
       // So, better crash now than later.
       DCHECK(dispatcher->HasOneRef()) << "AudioOutputProxies are still alive";
       dispatcher = NULL;
     }
@@ skipping 25 matching lines @@
   return GetPreferredOutputStreamParameters(AudioParameters());
 }
 
 AudioParameters AudioManagerBase::GetInputStreamParameters(
     const std::string& device_id) {
   NOTREACHED();
   return AudioParameters();
 }
 
 }  // namespace media