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 {

[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;
 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,
@@ skipping 18 matching lines @@
   DCHECK(context);
   CHECK(params_.IsValid());
 }
 
 PulseAudioInputStream::~PulseAudioInputStream() {
   // All internal structures should already have been freed in Close(),
   // which calls AudioManagerPulse::Release which deletes this object.
   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;
   }
 
   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_;
+}
+
+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,
                                          void* user_data) {
   PulseAudioInputStream* stream =
       reinterpret_cast<PulseAudioInputStream*>(user_data);
 
   stream->ReadData();
 }
 
@@ skipping 116 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