Cleanup AudioManager initialization on OSX to reduce startup delay.

media/audio/mac/audio_manager_mac.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/mac/audio_manager_mac.h"
 
 #include <CoreAudio/AudioHardware.h>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 243 matching lines @@
   bool is_suspending_;
   const bool is_monitoring_;
   base::TimeTicks earliest_start_time_;
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioPowerObserver);
 };
 
 AudioManagerMac::AudioManagerMac(AudioLogFactory* audio_log_factory)
     : AudioManagerBase(audio_log_factory),
-      current_sample_rate_(0) {
-  current_output_device_ = kAudioDeviceUnknown;
-
+      current_sample_rate_(0),
+      current_output_device_(kAudioDeviceUnknown) {
   SetMaxOutputStreamsAllowed(kMaxOutputStreams);
 
   // Task must be posted last to avoid races from handing out "this" to the
   // audio thread.  Always PostTask even if we're on the right thread since
   // AudioManager creation is on the startup path and this may be slow.
   GetTaskRunner()->PostTask(FROM_HERE, base::Bind(
-      &AudioManagerMac::CreateDeviceListener, base::Unretained(this)));
+      &AudioManagerMac::InitializeOnAudioThread, base::Unretained(this)));
 }
 
 AudioManagerMac::~AudioManagerMac() {
   if (GetTaskRunner()->BelongsToCurrentThread()) {
-    DestroyDeviceListener();
+    ShutdownOnAudioThread();
   } else {
     // It's safe to post a task here since Shutdown() will wait for all tasks to
     // complete before returning.
     GetTaskRunner()->PostTask(FROM_HERE, base::Bind(
-        &AudioManagerMac::DestroyDeviceListener, base::Unretained(this)));
+        &AudioManagerMac::ShutdownOnAudioThread, base::Unretained(this)));
   }
 
   Shutdown();
 }
 
 bool AudioManagerMac::HasAudioOutputDevices() {
   return HasAudioHardware(kAudioHardwarePropertyDefaultOutputDevice);
 }
 
 bool AudioManagerMac::HasAudioInputDevices() {
@@ skipping 264 matching lines @@
 }
 
 AudioOutputStream* AudioManagerMac::MakeLowLatencyOutputStream(
     const AudioParameters& params,
     const std::string& device_id) {
   AudioDeviceID device = GetAudioDeviceIdByUId(false, device_id);
   if (device == kAudioObjectUnknown) {
     DLOG(ERROR) << "Failed to open output device: " << device_id;
     return NULL;
   }
+
+  // Lazily create the audio device listener on the first stream creation.
+  if (!output_device_listener_) {
+    output_device_listener_.reset(new AudioDeviceListenerMac(base::Bind(
+        &AudioManagerMac::HandleDeviceChanges, base::Unretained(this))));
+    // Only set the current output device for the default device.
+    if (device_id == AudioManagerBase::kDefaultDeviceId || device_id.empty())
+      current_output_device_ = device;
+    // Just use the current sample rate since we don't allow non-native sample
+    // rates on OSX.
+    current_sample_rate_ = params.sample_rate();
+  }
+
   return new AUHALStream(this, params, device);
 }
 
 std::string AudioManagerMac::GetDefaultOutputDeviceID() {
   AudioDeviceID device_id = kAudioObjectUnknown;
   if (!GetDefaultOutputDevice(&device_id))
     return std::string();
 
   const AudioObjectPropertyAddress property_address = {
     kAudioDevicePropertyDeviceUID,
@@ skipping 90 matching lines @@
     // can be removed as part of the work to consolidate these back-ends.
     channel_layout = CHANNEL_LAYOUT_STEREO;
   }
 
   return AudioParameters(
       AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout, output_channels,
       input_channels, hardware_sample_rate, 16, buffer_size,
       AudioParameters::NO_EFFECTS);
 }
 
-void AudioManagerMac::CreateDeviceListener() {
+void AudioManagerMac::InitializeOnAudioThread() {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
-
-  // Get a baseline for the sample-rate and current device,
-  // so we can intelligently handle device notifications only when necessary.
-  current_sample_rate_ = HardwareSampleRate();
-  if (!GetDefaultOutputDevice(&current_output_device_))
-    current_output_device_ = kAudioDeviceUnknown;
-
-  output_device_listener_.reset(new AudioDeviceListenerMac(base::Bind(
-      &AudioManagerMac::HandleDeviceChanges, base::Unretained(this))));
   power_observer_.reset(new AudioPowerObserver());
 }
 
-void AudioManagerMac::DestroyDeviceListener() {
+void AudioManagerMac::ShutdownOnAudioThread() {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   output_device_listener_.reset();
   power_observer_.reset();
 }
 
 void AudioManagerMac::HandleDeviceChanges() {
   if (!GetTaskRunner()->BelongsToCurrentThread()) {
     GetTaskRunner()->PostTask(FROM_HERE, base::Bind(
         &AudioManagerMac::HandleDeviceChanges, base::Unretained(this)));
     return;
@@ skipping 32 matching lines @@
 bool AudioManagerMac::ShouldDeferOutputStreamStart() {
   DCHECK(GetTaskRunner()->BelongsToCurrentThread());
   return power_observer_->ShouldDeferOutputStreamStart();
 }
 
 AudioManager* CreateAudioManager(AudioLogFactory* audio_log_factory) {
   return new AudioManagerMac(audio_log_factory);
 }
 
 }  // namespace media