Link things together and enable the device selection for linux and mac.

media/audio/mac/audio_manager_mac.cc

 // Copyright (c) 2011 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 <CoreAudio/AudioHardware.h>
 
 #include "base/mac/mac_util.h"
+#include "base/mac/scoped_cftyperef.h"
 #include "base/sys_string_conversions.h"
 #include "media/audio/fake_audio_input_stream.h"
 #include "media/audio/fake_audio_output_stream.h"
 #include "media/audio/mac/audio_input_mac.h"
 #include "media/audio/mac/audio_low_latency_input_mac.h"
 #include "media/audio/mac/audio_low_latency_output_mac.h"
 #include "media/audio/mac/audio_manager_mac.h"
 #include "media/audio/mac/audio_output_mac.h"
 #include "media/base/limits.h"
 
@@ skipping 157 matching lines @@
     // We are responsible for releasing the returned CFObject.  See the
     // comment in the AudioHardware.h for constant
     // kAudioDevicePropertyDeviceUID.
     if (uid)
       CFRelease(uid);
     if (name)
       CFRelease(name);
   }
 }
 
+static AudioDeviceID GetAudioDeviceIdByUId(bool is_input,
+                                           const std::string& device_uid) {
+  AudioObjectPropertyAddress property_address = {
+    kAudioHardwarePropertyDevices,
+    kAudioObjectPropertyScopeGlobal,
+    kAudioObjectPropertyElementMaster
+  };
+  AudioDeviceID device_id = kAudioObjectUnknown;
+  UInt32 device_size = sizeof(device_id);
+  OSStatus result = -1;
+
+  if ((device_uid == AudioManagerBase::kDefaultDeviceId) ||
+      device_uid.empty()) {
+    // Default Device.
+    if (is_input)
+      property_address.mSelector = kAudioHardwarePropertyDefaultInputDevice;
+    else
+      property_address.mSelector = kAudioHardwarePropertyDefaultOutputDevice;
+
+    result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
+                                        &property_address,
+                                        0,
+                                        0,
+                                        &device_size,
+                                        &device_id);
+  } else {  // Non-default device.
+    base::mac::ScopedCFTypeRef<CFStringRef>
+        uid(base::SysUTF8ToCFStringRef(device_uid));
+    AudioValueTranslation value;
+    value.mInputData = &uid;
+    value.mInputDataSize = sizeof(CFStringRef);
+    value.mOutputData = &device_id;
+    value.mOutputDataSize = device_size;
+    UInt32 translation_size = sizeof(AudioValueTranslation);
+
+    property_address.mSelector = kAudioHardwarePropertyDeviceForUID;
+    result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
+                                        &property_address,
+                                        0, //translation_size,
+                                        0, //&value,
+                                        &translation_size,
+                                        &value);
+  }
+
+  if (result)
+    DLOG(WARNING) << "Unable to query device " << device_uid
+                  << " for AudioDeviceID ";
+
+  return device_id;
+}
+
 AudioManagerMac::AudioManagerMac()
     : num_output_streams_(0) {
 }
 
 AudioManagerMac::~AudioManagerMac() {
 }
 
 bool AudioManagerMac::HasAudioOutputDevices() {
   return HasAudioHardware(kAudioHardwarePropertyDefaultOutputDevice);
 }
 
 bool AudioManagerMac::HasAudioInputDevices() {
   return HasAudioHardware(kAudioHardwarePropertyDefaultInputDevice);
 }
 
 void AudioManagerMac::GetAudioInputDeviceNames(
     media::AudioDeviceNames* device_names) {
   // This is needed because AudioObjectGetPropertyDataSize has memory leak
   // when there is no soundcard in the machine.
   if (!HasAudioInputDevices())
     return;
 
   GetAudioDeviceInfo(true, device_names);
   if (!device_names->empty()) {
     // Prepend the default device to the list since we always want it to be
     // on the top of the list for all platforms. There is no duplicate
     // counting here since the default device has been abstracted out before.
     media::AudioDeviceName name;
     name.device_name = AudioManagerBase::kDefaultDeviceName;
-    name.unique_id = "0";
+    name.unique_id =  AudioManagerBase::kDefaultDeviceId;
     device_names->push_front(name);
   }
 }
 
 AudioOutputStream* AudioManagerMac::MakeAudioOutputStream(
     const AudioParameters& params) {
   if (!params.IsValid())
     return NULL;
 
   // Limit the number of audio streams opened. This is to prevent using
@@ skipping 10 matching lines @@
     num_output_streams_++;
     return new PCMQueueOutAudioOutputStream(this, params);
   } else if (params.format == AudioParameters::AUDIO_PCM_LOW_LATENCY) {
     num_output_streams_++;
     return new AUAudioOutputStream(this, params);
   }
   return NULL;
 }
 
 AudioInputStream* AudioManagerMac::MakeAudioInputStream(
-    const AudioParameters& params) {
+    const AudioParameters& params, const std::string& device_uid) {
   if (!params.IsValid() || (params.channels > kMaxInputChannels))
     return NULL;
 
   if (params.format == AudioParameters::AUDIO_MOCK) {
     return FakeAudioInputStream::MakeFakeStream(params);
   } else if (params.format == AudioParameters::AUDIO_PCM_LINEAR) {
     return new PCMQueueInAudioInputStream(this, params);
   } else if (params.format == AudioParameters::AUDIO_PCM_LOW_LATENCY) {
-    return new AUAudioInputStream(this, params);
+    AudioDeviceID audio_device_id = GetAudioDeviceIdByUId(true, device_uid);
+    if (audio_device_id != kAudioObjectUnknown)
+      return new AUAudioInputStream(this, params, audio_device_id);
   }
   return NULL;
 }
 
 void AudioManagerMac::MuteAll() {
   // TODO(cpu): implement.
 }
 
 void AudioManagerMac::UnMuteAll() {
   // TODO(cpu): implement.
 }
 
 // Called by the stream when it has been released by calling Close().
 void AudioManagerMac::ReleaseOutputStream(AudioOutputStream* stream) {
   DCHECK(stream);
   num_output_streams_--;
   delete stream;
 }
 
 // Called by the stream when it has been released by calling Close().
 void AudioManagerMac::ReleaseInputStream(AudioInputStream* stream) {
   delete stream;
 }
 
 // static
 AudioManager* AudioManager::CreateAudioManager() {
   return new AudioManagerMac();
 }