Handle audio device changes on Mac

media/audio/mac/audio_device_listener_mac.cc

Index: media/audio/mac/audio_device_listener_mac.cc
diff --git a/media/audio/mac/audio_device_listener_mac.cc b/media/audio/mac/audio_device_listener_mac.cc
new file mode 100644
index 0000000000000000000000000000000000000000..5db665d59fc355f1f2042a982939e54a8f28b2c7
--- /dev/null
+++ b/media/audio/mac/audio_device_listener_mac.cc
@@ -0,0 +1,80 @@
+// 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_device_listener_mac.h"
+
+#include <CoreAudio/CoreAudio.h>
+
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/logging.h"
+#include "base/mac/mac_logging.h"
+
+namespace {
+
+AudioObjectPropertySelector g_observed_properties[] = {

[DaleCurtis, 2012/10/29 21:11:32]

static const. Then the name should be styled kObservedProperties[] or
kPropertiesToObserve[]

[sail, 2012/10/29 21:38:28]

Changed to const. This doesn't need to be static since it's in an anonymous name
space.

+  kAudioHardwarePropertyDefaultOutputDevice,
+  kAudioDevicePropertyNominalSampleRate,
+};
+
+// Callback from system when the default device changes. This can be called
+// either on the main thread or on a audio thread managed by the system
+// (depending on what kAudioHardwarePropertyRunLoop is set to).
+OSStatus OnDefaultDeviceChangedCallback(
+    AudioObjectID object,
+    UInt32 size,
+    const AudioObjectPropertyAddress addresses[],
+    void* context) {
+  media::AudioDeviceListenerMac* listener =
+      static_cast<media::AudioDeviceListenerMac*>(context);
+  listener->OnDefaultDeviceChanged();
+  return noErr;
+}
+
+}  // namespace
+
+namespace media {
+
+AudioDeviceListenerMac::AudioDeviceListenerMac(const base::Closure& listener_cb)
+    : listener_cb_(listener_cb) {
+  for (size_t i = 0; i < arraysize(g_observed_properties); ++i) {
+    AudioObjectPropertyAddress property = {
+      g_observed_properties[i],
+      kAudioObjectPropertyScopeGlobal,
+      kAudioObjectPropertyElementMaster
+    };
+    OSStatus result = AudioObjectAddPropertyListener(
+        kAudioObjectSystemObject,
+        &property,
+        &OnDefaultDeviceChangedCallback,
+        this);
+    OSSTATUS_DCHECK(result == noErr, result);
+  }
+}
+
+AudioDeviceListenerMac::~AudioDeviceListenerMac() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  base::AutoLock auto_lock(lock_);

[Scott Hess - ex-Googler, 2012/10/29 21:04:02]

AFAICT, you have this lock to prevent races WRT OnDefaultDeviceChanged()
messaging the callback?  I'm worried that holding this lock while the callback
is being called could lead to deadlock.  But I'm not thinking my way out of that
box, so maybe I'll ignore it.

That said, there is a definite problem, here, as if
OnDefaultDeviceChangedCallback() is called after this has gotten the lock, it
could end up messaging a destructed |this|.

[DaleCurtis, 2012/10/29 21:11:32]

Does this cause races during destruction? I assume not, but watch TSAN.

Also, is it enough to hold the lock indefinitely during destruction?  What
happens in OnDefaultDeviceChanged() if the lock is destructed while another
thread is waiting?  At best it seems racy, at worst it would be a use after
free.

If you put an AutoUnlock inside the loop below after calling
AudioObjectRemovePropertyListener that will guarantee that there are no
outstanding callbacks.  Since each unlock will allow one listener to complete
and after each RemovePropertyListenerCall we know (I hope!) that callback can't
be called again.

[sail, 2012/10/29 21:38:28]

Done.

[DaleCurtis, 2012/10/29 21:57:14]

You should double check my logic here to ensure this actually lets other threads
through and doesn't just immediately reacquire the lock.  I can't remember if
contention is FIFO based or not with pthreads, Windows explicitly provides no
guarantee of ordering.

[Scott Hess - ex-Googler, 2012/10/29 22:19:22]

I'm finding myself nervous, here.  I'm wondering if a less brittle option is
available.

If this were a chrome-style callback, a weak pointer factory would be the way to
go.  But that's not going to work.

One option might be to have a single global callback, with a vector of
interested objects protected by a lock.  The constructor would add itself to the
list (under a lock) and register the callback if it's the first object.  The
destructor would remove itself from the list (under a lock) and terminate the
callback if empty.  Since construction and destruction are bound to a single
thread, I don't think you need to debounce that, unless listeners can
individually be constructed on different threads.

+
+  for (size_t i = 0; i < arraysize(g_observed_properties); ++i) {
+    AudioObjectPropertyAddress property = {
+      g_observed_properties[i],
+      kAudioObjectPropertyScopeGlobal,
+      kAudioObjectPropertyElementMaster
+    };
+    OSStatus result = AudioObjectRemovePropertyListener(
+        kAudioObjectSystemObject,
+        &property,
+        &OnDefaultDeviceChangedCallback,
+        this);
+    OSSTATUS_DCHECK(result == noErr, result);
+  }
+}
+
+void AudioDeviceListenerMac::OnDefaultDeviceChanged() {
+  base::AutoLock auto_lock(lock_);
+  listener_cb_.Run();
+}
+
+}  // namespace media