AudioManagerBase: Create and run the audio thread lazily.

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 <stdint.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 352 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(AudioPowerObserver);
 };
 
 AudioManagerMac::AudioManagerMac(AudioLogFactory* audio_log_factory)
     : AudioManagerBase(audio_log_factory),
       current_sample_rate_(0),
       current_output_device_(kAudioDeviceUnknown) {
   SetMaxOutputStreamsAllowed(kMaxOutputStreams);
 
+  // CoreAudio calls must occur on the main thread of the process, which in our
+  // case is sadly the browser UI thread.  Failure to execute calls on the right
+  // thread leads to crashes and odd behavior.  See http://crbug.com/158170.
+  // TODO(dalecurtis): We should require the message loop to be passed in.
+  task_runner_ = base::MessageLoopForUI::IsCurrent()
+                     ? base::ThreadTaskRunnerHandle::Get()
+                     : AudioManagerBase::GetTaskRunner();
+
   // 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::InitializeOnAudioThread, base::Unretained(this)));
+  task_runner_->PostTask(FROM_HERE,
+                         base::Bind(&AudioManagerMac::InitializeOnAudioThread,
+                                    base::Unretained(this)));
 }
 
 AudioManagerMac::~AudioManagerMac() {
-  if (GetTaskRunner()->BelongsToCurrentThread()) {
+  if (task_runner_->BelongsToCurrentThread()) {
     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::ShutdownOnAudioThread, base::Unretained(this)));
+    task_runner_->PostTask(FROM_HERE,
+                           base::Bind(&AudioManagerMac::ShutdownOnAudioThread,
+                                      base::Unretained(this)));
   }
 
   Shutdown();
 }
 
+scoped_refptr<base::SingleThreadTaskRunner> AudioManagerMac::GetTaskRunner() {
+  return task_runner_;
+}
+
+scoped_refptr<base::SingleThreadTaskRunner>
+AudioManagerMac::GetWorkerTaskRunner() {
+  if (!worker_thread_) {
+    worker_thread_.reset(new base::Thread("AudioWorkerThread"));
+    CHECK(worker_thread_->Start());
+  }
+  return worker_thread_->task_runner();
+}
+
 bool AudioManagerMac::HasAudioOutputDevices() {
   return HasAudioHardware(kAudioHardwarePropertyDefaultOutputDevice);
 }
 
 bool AudioManagerMac::HasAudioInputDevices() {
   return HasAudioHardware(kAudioHardwarePropertyDefaultInputDevice);
 }
 
+// static
 bool AudioManagerMac::GetDeviceChannels(AudioDeviceID device,
                                         AudioObjectPropertyScope scope,
                                         int* channels) {
   DCHECK(AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
   CHECK(channels);
   const bool is_input = (scope == kAudioDevicePropertyScopeInput);
   DVLOG(1) << "GetDeviceChannels(id=0x" << std::hex << device
            << ", is_input=" << is_input << ")";
 
   // Get the stream configuration of the device in an AudioBufferList (with the
@@ skipping 23 matching lines @@
   // TODO(henrika): add UMA stats to track utilized hardware configurations.
   int num_channels = 0;
   for (UInt32 i = 0; i < buffer_list.mNumberBuffers; ++i) {
     num_channels += buffer_list.mBuffers[i].mNumberChannels;
   }
   *channels = num_channels;
   DVLOG(1) << "#channels: " << *channels;
   return true;
 }
 
+// static
 int AudioManagerMac::HardwareSampleRateForDevice(AudioDeviceID device_id) {
   DCHECK(AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
   Float64 nominal_sample_rate;
   UInt32 info_size = sizeof(nominal_sample_rate);
 
   static const AudioObjectPropertyAddress kNominalSampleRateAddress = {
       kAudioDevicePropertyNominalSampleRate,
       kAudioObjectPropertyScopeGlobal,
       kAudioObjectPropertyElementMaster
   };
   OSStatus result = AudioObjectGetPropertyData(device_id,
                                                &kNominalSampleRateAddress,
                                                0,
                                                0,
                                                &info_size,
                                                &nominal_sample_rate);
   if (result != noErr) {
     OSSTATUS_DLOG(WARNING, result)
         << "Could not get default sample rate for device: " << device_id;
     return 0;
   }
 
   return static_cast<int>(nominal_sample_rate);
 }
 
+// static
 int AudioManagerMac::HardwareSampleRate() {
   // Determine the default output device's sample-rate.
   AudioDeviceID device_id = kAudioObjectUnknown;
   if (!GetDefaultOutputDevice(&device_id))
     return kFallbackSampleRate;
 
   return HardwareSampleRateForDevice(device_id);
 }
 
 void AudioManagerMac::GetAudioInputDeviceNames(
@@ skipping 38 matching lines @@
   const int buffer_size = ChooseBufferSize(true, sample_rate);
 
   // TODO(xians): query the native channel layout for the specific device.
   return AudioParameters(
       AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout,
       sample_rate, 16, buffer_size);
 }
 
 std::string AudioManagerMac::GetAssociatedOutputDeviceID(
     const std::string& input_device_id) {
-  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   AudioDeviceID device = GetAudioDeviceIdByUId(true, input_device_id);
   if (device == kAudioObjectUnknown)
     return std::string();
 
   UInt32 size = 0;
   AudioObjectPropertyAddress pa = {
     kAudioDevicePropertyRelatedDevices,
     kAudioDevicePropertyScopeOutput,
     kAudioObjectPropertyElementMaster
   };
@@ skipping 104 matching lines @@
     // rates on OSX.
     current_sample_rate_ = params.sample_rate();
   }
 
   AUHALStream* stream = new AUHALStream(this, params, device);
   output_streams_.push_back(stream);
   return stream;
 }
 
 std::string AudioManagerMac::GetDefaultOutputDeviceID() {
-  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   AudioDeviceID device_id = kAudioObjectUnknown;
   if (!GetDefaultOutputDevice(&device_id))
     return std::string();
 
   const AudioObjectPropertyAddress property_address = {
     kAudioDevicePropertyDeviceUID,
     kAudioObjectPropertyScopeGlobal,
     kAudioObjectPropertyElementMaster
   };
   CFStringRef device_uid = NULL;
@@ skipping 78 matching lines @@
       channel_layout = CHANNEL_LAYOUT_DISCRETE;
   }
 
   AudioParameters params(AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout,
                          hardware_sample_rate, 16, buffer_size);
   params.set_channels_for_discrete(output_channels);
   return params;
 }
 
 void AudioManagerMac::InitializeOnAudioThread() {
-  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   power_observer_.reset(new AudioPowerObserver());
 }
 
 void AudioManagerMac::ShutdownOnAudioThread() {
-  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   output_device_listener_.reset();
   power_observer_.reset();
 
   // Since CoreAudio calls have to run on the UI thread and browser shutdown
   // doesn't wait for outstanding tasks to complete, we may have input/output
   // streams still running at shutdown.
   //
   // To avoid calls into destructed classes, we need to stop the OS callbacks
   // by stopping the streams.  Note: The streams are leaked since process
   // destruction is imminent.
   //
   // See http://crbug.com/354139 for crash details.
   StopStreams(&basic_input_streams_);
   StopStreams(&low_latency_input_streams_);
   StopStreams(&output_streams_);
 }
 
 void AudioManagerMac::HandleDeviceChanges() {
-  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   const int new_sample_rate = HardwareSampleRate();
   AudioDeviceID new_output_device;
   GetDefaultOutputDevice(&new_output_device);
 
   if (current_sample_rate_ == new_sample_rate &&
       current_output_device_ == new_output_device) {
     return;
   }
 
   current_sample_rate_ = new_sample_rate;
@@ skipping 21 matching lines @@
     if (sample_rate <= 96000)
       buffer_size = 2 * kMinimumInputOutputBufferSize;
     else if (sample_rate <= 192000)
       buffer_size = 4 * kMinimumInputOutputBufferSize;
   }
 
   return buffer_size;
 }
 
 bool AudioManagerMac::ShouldDeferStreamStart() const {
-  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   return power_observer_->ShouldDeferStreamStart();
 }
 
 bool AudioManagerMac::IsOnBatteryPower() const {
-  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   return power_observer_->IsOnBatteryPower();
 }
 
 size_t AudioManagerMac::GetNumberOfResumeNotifications() const {
-  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   return power_observer_->num_resume_notifications();
 }
 
 bool AudioManagerMac::MaybeChangeBufferSize(AudioDeviceID device_id,
                                             AudioUnit audio_unit,
                                             AudioUnitElement element,
                                             size_t desired_buffer_size,
                                             bool* size_was_changed,
                                             size_t* io_buffer_frame_size) {
-  DCHECK(GetTaskRunner()->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
   const bool is_input = (element == 1);
   DVLOG(1) << "MaybeChangeBufferSize(id=0x" << std::hex << device_id
            << ", is_input=" << is_input << ", desired_buffer_size=" << std::dec
            << desired_buffer_size << ")";
 
   *size_was_changed = false;
   *io_buffer_frame_size = 0;
 
   // Log the device name (and id) for debugging purposes.
   std::string device_name = GetAudioDeviceNameFromDeviceId(device_id, is_input);
@@ skipping 104 matching lines @@
     basic_input_streams_.erase(stream_it);
 
   AudioManagerBase::ReleaseInputStream(stream);
 }
 
 AudioManager* CreateAudioManager(AudioLogFactory* audio_log_factory) {
   return new AudioManagerMac(audio_log_factory);
 }
 
 }  // namespace media