Let default device in PulseAudio be the system default device

media/audio/pulse/pulse_output.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_output.h"
 
 #include <pulse/pulseaudio.h>
 #include <stdint.h>
 
 #include "base/single_thread_task_runner.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/audio/pulse/pulse_util.h"
 
 namespace media {
 
 using pulse::AutoPulseLock;
 using pulse::WaitForOperationCompletion;
 
+// Helper macro to avoid code spam and string bloat.
+#define RETURN_ON_FAILURE(expression, message) \

[tommi (sloooow) - chröme, 2016/03/16 15:21:47]

macros are discouraged and especially ones that have a return statement. Can you
think of a way to do this without it?

[rchtara, 2016/03/19 12:07:30]

Done.

+  do {                                         \
+    if (!(expression)) {                       \
+      DLOG(ERROR) << message;                  \
+      return false;                            \
+    }                                          \
+  } while (0)
+
 // static, pa_stream_notify_cb
 void PulseAudioOutputStream::StreamNotifyCallback(pa_stream* s, void* p_this) {
   PulseAudioOutputStream* stream = static_cast<PulseAudioOutputStream*>(p_this);
 
   // Forward unexpected failures to the AudioSourceCallback if available.  All
   // these variables are only modified under pa_threaded_mainloop_lock() so this
   // should be thread safe.
   if (s && stream->source_callback_ &&
       pa_stream_get_state(s) == PA_STREAM_FAILED) {
     stream->source_callback_->OnError(stream);
@@ skipping 25 matching lines @@
 }
 
 PulseAudioOutputStream::~PulseAudioOutputStream() {
   // All internal structures should already have been freed in Close(), which
   // calls AudioManagerBase::ReleaseOutputStream() which deletes this object.
   DCHECK(!pa_stream_);
   DCHECK(!pa_context_);
   DCHECK(!pa_mainloop_);
 }
 
+bool PulseAudioOutputStream::InitializeMainloopAndContext() {
+  DCHECK(!pa_mainloop_);
+  DCHECK(!pa_context_);
+  DCHECK(thread_checker_.CalledOnValidThread());
+  pa_mainloop_ = pa_threaded_mainloop_new();
+  RETURN_ON_FAILURE(pa_mainloop_, "Failed to create PulseAudio main loop.");
+
+  pa_mainloop_api* pa_mainloop_api = pa_threaded_mainloop_get_api(pa_mainloop_);
+  std::string app_name = AudioManager::GetGlobalAppName();
+  pa_context_ = pa_context_new(
+      pa_mainloop_api, app_name.empty() ? "Chromium" : app_name.c_str());

[tommi (sloooow) - chröme, 2016/03/16 15:21:47]

When do we get an empty string from GetGlobalAppName?

[rchtara, 2016/03/19 12:07:30]

I'm just moving some code from CreateOutputStream to here and I'm not sure if
that could happen or not.
So, this why I prefer keeping things as they were to avoid bugs. 

GetGlobalAppName says that it returns the app name or an empty string if it is
not set. So it's probably possible for it to return empty string.
https://code.google.com/p/chromium/codesearch#chromium/src/media/audio/audio_...

Using the app name was introduced here by the way.
https://codereview.chromium.org/1317033006/

+  RETURN_ON_FAILURE(pa_context_, "Failed to create PulseAudio context.");
+
+  // A state callback must be set before calling pa_threaded_mainloop_lock() or
+  // pa_threaded_mainloop_wait() calls may lead to dead lock.
+  pa_context_set_state_callback(pa_context_, &pulse::ContextStateCallback,
+                                pa_mainloop_);
+  {
+    // Lock the main loop while setting up the context.  Failure to do so may
+    // lead to crashes as the PulseAudio thread tries to run before things are
+    // ready.
+    AutoPulseLock auto_lock(pa_mainloop_);
+
+    RETURN_ON_FAILURE(pa_threaded_mainloop_start(pa_mainloop_) == 0,
+                      "Failed to start PulseAudio main loop.");
+    RETURN_ON_FAILURE(pa_context_connect(pa_context_, NULL,
+                                         PA_CONTEXT_NOAUTOSPAWN, NULL) == 0,
+                      "Failed to connect PulseAudio context.");
+
+    // Wait until |pa_context_| is ready.  pa_threaded_mainloop_wait() must be
+    // called after pa_context_get_state() in case the context is already ready,
+    // otherwise pa_threaded_mainloop_wait() will hang indefinitely.
+    while (true) {
+      pa_context_state_t context_state = pa_context_get_state(pa_context_);
+      RETURN_ON_FAILURE(PA_CONTEXT_IS_GOOD(context_state),
+                        "Invalid PulseAudio context state.");
+      if (context_state == PA_CONTEXT_READY)
+        break;
+      pa_threaded_mainloop_wait(pa_mainloop_);
+    }
+  }
+
+  return true;
+}
+
+// static, used by pa_context_get_server_info.
+void PulseAudioOutputStream::GetSystemDefaultOutputDeviceCallback(
+    pa_context* context,
+    const pa_server_info* info,
+    void* user_data) {
+  media::PulseAudioOutputStream* stream =
+      reinterpret_cast<media::PulseAudioOutputStream*>(user_data);
+  stream->default_system_device_name_ = info->default_sink_name;
+  pa_threaded_mainloop_signal(stream->pa_mainloop_, 0);
+}
+
+void PulseAudioOutputStream::GetSystemDefaultOutputDevice() {
+  DCHECK(pa_mainloop_);
+  DCHECK(pa_context_);
+  pa_operation* operation = pa_context_get_server_info(
+      pa_context_, PulseAudioOutputStream::GetSystemDefaultOutputDeviceCallback,
+      this);
+  WaitForOperationCompletion(pa_mainloop_, operation);
+}
+
 bool PulseAudioOutputStream::Open() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!InitializeMainloopAndContext()) {
+    return false;
+  }
+
+  AutoPulseLock auto_lock(pa_mainloop_);
+
+  std::string device_name_to_use = device_id_;
+  if (device_id_ == AudioManagerBase::kDefaultDeviceId) {
+    GetSystemDefaultOutputDevice();
+    device_name_to_use = default_system_device_name_;
+  }
+
   return pulse::CreateOutputStream(
-      &pa_mainloop_, &pa_context_, &pa_stream_, params_, device_id_,
+      pa_mainloop_, pa_context_, &pa_stream_, params_, device_name_to_use,
       AudioManager::GetGlobalAppName(), &StreamNotifyCallback,
       &StreamRequestCallback, this);
 }
 
 void PulseAudioOutputStream::Reset() {
   if (!pa_mainloop_) {
     DCHECK(!pa_stream_);
     DCHECK(!pa_context_);
     return;
   }
@@ skipping 151 matching lines @@
   volume_ = static_cast<float>(volume);
 }
 
 void PulseAudioOutputStream::GetVolume(double* volume) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   *volume = volume_;
 }
 
 }  // namespace media