Let default device in PulseAudio be the system default device

media/audio/pulse/pulse_input.cc

Index: media/audio/pulse/pulse_input.cc
diff --git a/media/audio/pulse/pulse_input.cc b/media/audio/pulse/pulse_input.cc
index 8d4aeea2079d201a69e52fb48e4344680c467d70..6c5668becd9d69ab2c2d489d9f9644d961f2ed07 100644
--- a/media/audio/pulse/pulse_input.cc
+++ b/media/audio/pulse/pulse_input.cc
@@ -10,6 +10,22 @@
 #include "media/audio/pulse/audio_manager_pulse.h"
 #include "media/audio/pulse/pulse_util.h"
 
+namespace {

[Henrik Grunell, 2016/03/10 00:57:07]

Put the anonymous namespace inside the media namespace.

[rchtara, 2016/03/10 13:20:34]

Done.

+
+// 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* pa_mainloop = stream->GetPAMainloop();
+  pa_threaded_mainloop_signal(pa_mainloop, 0);
+}
+}

[Henrik Grunell, 2016/03/10 00:57:07]

}

}  // namespace

[rchtara, 2016/03/10 13:20:34]

Done.

+
 namespace media {
 
 using pulse::AutoPulseLock;
@@ -48,11 +64,26 @@ PulseAudioInputStream::~PulseAudioInputStream() {
   DCHECK(!handle_);
 }
 
+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);
+}
+
 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;
   }
 
@@ -197,6 +228,15 @@ bool PulseAudioInputStream::IsMuted() {
   return muted_;
 }
 
+pa_threaded_mainloop* PulseAudioInputStream::GetPAMainloop() {
+  return pa_mainloop_;
+}
+
+void PulseAudioInputStream::SetDefaultSystemDeviceName(
+    const std::string& name) {
+  default_system_device_name_ = name;

[Henrik Grunell, 2016/03/10 00:57:07]

Either add a thread check or lock. Seems like we can't use a thread checker,
right? I think the callback that in turn calls this function is on another
thread than Open() is called on, is that correct?

[rchtara, 2016/03/10 13:20:34]

DCHECK(stream->thread_checker_.CalledOnValidThread()) on the callback thread
causes a crash so they 're different threads.
Using a lock doesn't work either as we are not in the right thread:
Assertion '!m->thread || !pa_thread_is_running(m->thread) || !in_worker(m)'
failed at pulse/thread-mainloop.c:169, function pa_threaded_mainloop_lock().
Aborting

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

Seems you were using the pulse auto lock. Instead add a new ordinary lock
(base::Lock) as a member, then use base::AutoLock to acquire and auto release.

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

Done.

+}
+
 // static, used by pa_stream_set_read_callback.
 void PulseAudioInputStream::ReadCallback(pa_stream* handle,
                                          size_t length,