Let default device in PulseAudio be the system default device

media/audio/pulse/pulse_input.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/pulse/pulse_input.h"
 
 #include <stdint.h>
 
 #include "base/logging.h"
 #include "media/audio/pulse/audio_manager_pulse.h"
 #include "media/audio/pulse/pulse_util.h"
 
 namespace media {
 
+namespace {
+
+// pa_context_get_server_info callback. It's used by
+// GetSystemDefaultInputDevice to set |default_system_device_name_| to the
+// default system input device.
+void GetSystemDefaultInputDeviceCallback(pa_context* context,
+                                         const pa_server_info* info,
+                                         void* user_data) {
+  media::PulseAudioInputStream* stream =
+      reinterpret_cast<media::PulseAudioInputStream*>(user_data);
+  stream->SetDefaultSystemDeviceName(info->default_source_name);
+  pa_threaded_mainloop_signal(stream->GetPAMainloop(), 0);
+}
+
+}  // namespace
+
 using pulse::AutoPulseLock;
 using pulse::WaitForOperationCompletion;
 
 // Number of blocks of buffers used in the |fifo_|.
 const int kNumberOfBlocksBufferInFifo = 2;
 
 PulseAudioInputStream::PulseAudioInputStream(AudioManagerPulse* audio_manager,
                                              const std::string& device_name,
                                              const AudioParameters& params,
                                              pa_threaded_mainloop* mainloop,
@@ skipping 19 matching lines @@
 
 PulseAudioInputStream::~PulseAudioInputStream() {
   // All internal structures should already have been freed in Close(),
   // which calls AudioManagerPulse::Release which deletes this object.
   DCHECK(!handle_);
 }
 
 bool PulseAudioInputStream::Open() {
   DCHECK(thread_checker_.CalledOnValidThread());
   AutoPulseLock auto_lock(pa_mainloop_);
+  std::string device_name_to_use = device_name_;
+  if (device_name_ == AudioManagerBase::kDefaultDeviceId) {
+    GetSystemDefaultInputDevice();
+    device_name_to_use = default_system_device_name_;
+  }
+
   if (!pulse::CreateInputStream(pa_mainloop_, pa_context_, &handle_, params_,
-                                device_name_, &StreamNotifyCallback, this)) {
+                                device_name_to_use, &StreamNotifyCallback,
+                                this)) {
     return false;
   }
 
   DCHECK(handle_);
 
   return true;
 }
 
 void PulseAudioInputStream::Start(AudioInputCallback* callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 124 matching lines @@
     return volume_;
   }
 }
 
 bool PulseAudioInputStream::IsMuted() {
   DCHECK(thread_checker_.CalledOnValidThread());
   GetSourceInformation(&MuteCallback);
   return muted_;
 }
 
+pa_threaded_mainloop* PulseAudioInputStream::GetPAMainloop() {
+  return pa_mainloop_;

[Henrik Grunell, 2016/03/10 20:07:34]

Could this function be called at the same time as setting the variable in
Open()? I don't think so, but can you verify that not possible?

[rchtara, 2016/03/11 10:13:09]

PulseAudioInputStream::Open is going to lock the main loop until the stream is
open (which includes calling: PulseAudioInputStream::GetPAMainloop).
In case a concurrent call to Open happens, it's going to wait until the first 
one has finished. 
so this function could not be called at the same time as setting the variable in
Open()

[Henrik Grunell, 2016/03/11 18:54:41]

Acknowledged.

[rchtara, 2016/03/13 15:12:00]

Done.

+}
+
+void PulseAudioInputStream::SetDefaultSystemDeviceName(
+    const std::string& name) {
+  default_system_device_name_ = name;
+}
+
 // static, used by pa_stream_set_read_callback.
 void PulseAudioInputStream::ReadCallback(pa_stream* handle,
                                          size_t length,
                                          void* user_data) {
   PulseAudioInputStream* stream =
       reinterpret_cast<PulseAudioInputStream*>(user_data);
 
   stream->ReadData();
 }
 
@@ skipping 51 matching lines @@
       reinterpret_cast<PulseAudioInputStream*>(user_data);
 
   if (s && stream->callback_ &&
       pa_stream_get_state(s) == PA_STREAM_FAILED) {
     stream->callback_->OnError(stream);
   }
 
   pa_threaded_mainloop_signal(stream->pa_mainloop_, 0);
 }
 
+void PulseAudioInputStream::GetSystemDefaultInputDevice() {
+  DCHECK(pa_mainloop_);
+  DCHECK(pa_context_);
+  pa_operation* operation = pa_context_get_server_info(
+      pa_context_, GetSystemDefaultInputDeviceCallback, this);
+  WaitForOperationCompletion(pa_mainloop_, operation);
+}
+
 void PulseAudioInputStream::ReadData() {
   uint32_t hardware_delay = pulse::GetHardwareLatencyInBytes(
       handle_, params_.sample_rate(), params_.GetBytesPerFrame());
 
   // Update the AGC volume level once every second. Note that,
   // |volume| is also updated each time SetVolume() is called
   // through IPC by the render-side AGC.
   // We disregard the |normalized_volume| from GetAgcVolume()
   // and use the value calculated by |volume_|.
   double normalized_volume = 0.0;
@@ skipping 45 matching lines @@
     return false;
 
   size_t index = pa_stream_get_device_index(handle_);
   pa_operation* operation =
       pa_context_get_source_info_by_index(pa_context_, index, callback, this);
   WaitForOperationCompletion(pa_mainloop_, operation);
   return true;
 }
 
 }  // namespace media