Use "application default" audio device as default PulseAudio device.

media/audio/pulse/pulse_util.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_util.h"
 
 #include <stdint.h>
 
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 152 matching lines @@
 
 bool CreateInputStream(pa_threaded_mainloop* mainloop,
                        pa_context* context,
                        pa_stream** stream,
                        const AudioParameters& params,
                        const std::string& device_id,
                        pa_stream_notify_cb_t stream_callback,
                        void* user_data) {
   DCHECK(mainloop);
   DCHECK(context);
-  DCHECK_NE(device_id, AudioManagerBase::kDefaultDeviceId);
 
   // Set sample specifications.
   pa_sample_spec sample_specifications;
   sample_specifications.format = BitsToPASampleFormat(
       params.bits_per_sample());
   sample_specifications.rate = params.sample_rate();
   sample_specifications.channels = params.channels();
 
   // Get channel mapping and open recording stream.
   pa_channel_map source_channel_map = ChannelLayoutToPAChannelMap(
@@ skipping 21 matching lines @@
   buffer_attributes.maxlength = static_cast<uint32_t>(-1);
   buffer_attributes.tlength = buffer_size;
   buffer_attributes.minreq = buffer_size;
   buffer_attributes.prebuf = static_cast<uint32_t>(-1);
   buffer_attributes.fragsize = buffer_size;
   int flags = PA_STREAM_AUTO_TIMING_UPDATE |
               PA_STREAM_INTERPOLATE_TIMING |
               PA_STREAM_ADJUST_LATENCY |
               PA_STREAM_START_CORKED;
   RETURN_ON_FAILURE(
-      pa_stream_connect_record(*stream, device_id.c_str(), &buffer_attributes,
-                               static_cast<pa_stream_flags_t>(flags)) == 0,
+      pa_stream_connect_record(
+          *stream,
+          device_id == AudioManagerBase::kDefaultDeviceId ?
+              NULL : device_id.c_str(),
+          &buffer_attributes,
+          static_cast<pa_stream_flags_t>(flags)) == 0,
       "pa_stream_connect_record FAILED ");
 
   // Wait for the stream to be ready.
   while (true) {
     pa_stream_state_t stream_state = pa_stream_get_state(*stream);
     RETURN_ON_FAILURE(
         PA_STREAM_IS_GOOD(stream_state), "Invalid PulseAudio stream state");
     if (stream_state == PA_STREAM_READY)
         break;
     pa_threaded_mainloop_wait(mainloop);
   }
 
   return true;
 }
 
-bool CreateOutputStream(pa_threaded_mainloop* mainloop,
-                        pa_context* context,
+bool CreateOutputStream(pa_threaded_mainloop** mainloop,
+                        pa_context** context,
                         pa_stream** stream,
                         const AudioParameters& params,
                         const std::string& device_id,
                         const std::string& app_name,
                         pa_stream_notify_cb_t stream_callback,
                         pa_stream_request_cb_t write_callback,
                         void* user_data) {
-  DCHECK(mainloop);
-  DCHECK(context);
-  DCHECK(device_id != AudioManagerBase::kDefaultDeviceId);
+  DCHECK(!*mainloop);
+  DCHECK(!*context);
+
+  *mainloop = pa_threaded_mainloop_new();
+  RETURN_ON_FAILURE(*mainloop, "Failed to create PulseAudio main loop.");
+
+  pa_mainloop_api* pa_mainloop_api = pa_threaded_mainloop_get_api(*mainloop);
+  *context = pa_context_new(pa_mainloop_api,
+                            app_name.empty() ? "Chromium" : app_name.c_str());
+  RETURN_ON_FAILURE(*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(*context, &ContextStateCallback, *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(*mainloop);
+
+  RETURN_ON_FAILURE(pa_threaded_mainloop_start(*mainloop) == 0,
+                    "Failed to start PulseAudio main loop.");
+  RETURN_ON_FAILURE(
+      pa_context_connect(*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(*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(*mainloop);
+  }
 
   // Set sample specifications.
   pa_sample_spec sample_specifications;
   sample_specifications.format = BitsToPASampleFormat(
       params.bits_per_sample());
   sample_specifications.rate = params.sample_rate();
   sample_specifications.channels = params.channels();
 
   // Get channel mapping.
   pa_channel_map* map = NULL;
   pa_channel_map source_channel_map = ChannelLayoutToPAChannelMap(
       params.channel_layout());
   if (source_channel_map.channels != 0) {
     // The source data uses a supported channel map so we will use it rather
     // than the default channel map (NULL).
     map = &source_channel_map;
   }
 
   // Open playback stream and
   // tell PulseAudio what the stream icon should be.
   ScopedPropertyList property_list;
   pa_proplist_sets(property_list.get(), PA_PROP_APPLICATION_ICON_NAME,
                    kBrowserDisplayName);
   *stream = pa_stream_new_with_proplist(
-      context, "Playback", &sample_specifications, map, property_list.get());
+      *context, "Playback", &sample_specifications, map, property_list.get());
   RETURN_ON_FAILURE(*stream, "failed to create PA playback stream");
 
   pa_stream_set_state_callback(*stream, stream_callback, user_data);
 
   // Even though we start the stream corked above, PulseAudio will issue one
   // stream request after setup.  write_callback() must fulfill the write.
   pa_stream_set_write_callback(*stream, write_callback, user_data);
 
   // Pulse is very finicky with the small buffer sizes used by Chrome.  The
   // settings below are mostly found through trial and error.  Essentially we
@@ skipping 10 matching lines @@
   pa_buffer_attributes.minreq = params.GetBytesPerBuffer() / 2;
   pa_buffer_attributes.prebuf = static_cast<uint32_t>(-1);
   pa_buffer_attributes.tlength = params.GetBytesPerBuffer() * 3;
   pa_buffer_attributes.fragsize = static_cast<uint32_t>(-1);
 
   // Connect playback stream.  Like pa_buffer_attr, the pa_stream_flags have a
   // huge impact on the performance of the stream and were chosen through trial
   // and error.
   RETURN_ON_FAILURE(
       pa_stream_connect_playback(
-          *stream, device_id.c_str(), &pa_buffer_attributes,
+          *stream,
+          device_id == AudioManagerBase::kDefaultDeviceId ?
+              NULL : device_id.c_str(),
+          &pa_buffer_attributes,
           static_cast<pa_stream_flags_t>(
               PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_ADJUST_LATENCY |
               PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_NOT_MONOTONIC |
               PA_STREAM_START_CORKED),
-          NULL, NULL) == 0,
+          NULL,
+          NULL) == 0,
       "pa_stream_connect_playback FAILED ");
 
   // Wait for the stream to be ready.
   while (true) {
     pa_stream_state_t stream_state = pa_stream_get_state(*stream);
     RETURN_ON_FAILURE(
         PA_STREAM_IS_GOOD(stream_state), "Invalid PulseAudio stream state");
     if (stream_state == PA_STREAM_READY)
       break;
-    pa_threaded_mainloop_wait(mainloop);
+    pa_threaded_mainloop_wait(*mainloop);
   }
 
   return true;
 }
 
 #undef RETURN_ON_FAILURE
 
 }  // namespace pulse
 
 }  // namespace media