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 255 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 267 matching lines @@
     const AudioParameters& params,
     const std::string& device_id,
     const std::string& input_device_id) {
   // Handle basic output with no input channels.
   if (params.input_channels() == 0) {
     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.empty())

[tommi (sloooow) - chröme, 2014/02/13 06:56:20]

Check for AudioManagerBase::kDefaultDeviceId?

[DaleCurtis, 2014/02/13 19:24:35]

That's only for input no?

[DaleCurtis, 2014/02/13 20:31:53]

Done.

+        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);
   }
 
   DLOG_IF(ERROR, !device_id.empty()) << "Not implemented!";
 
   // TODO(xians): support more than stereo input.
   if (params.input_channels() != 2) {
     // WebAudio is currently hard-coded to 2 channels so we should not
     // see this case.
     NOTREACHED() << "Only stereo input is currently supported!";
@@ skipping 141 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