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

media/audio/linux/audio_manager_linux.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 "media/audio/linux/audio_manager_linux.h"
 
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/nix/xdg_util.h"
@@ skipping 18 matching lines @@
 
 // Since "default", "pulse" and "dmix" devices are virtual devices mapped to
 // real devices, we remove them from the list to avoiding duplicate counting.
 // In addition, note that we support no more than 2 channels for recording,
 // hence surround devices are not stored in the list.
 static const char* kInvalidAudioInputDevices[] = {
   "default",
   "null",
   "pulse",
   "dmix",
-  "surround",
 };
 
 // Implementation of AudioManager.
 bool AudioManagerLinux::HasAudioOutputDevices() {
   return HasAnyAlsaAudioDevice(kStreamPlayback);
 }
 
 bool AudioManagerLinux::HasAudioInputDevices() {
   return HasAnyAlsaAudioDevice(kStreamCapture);
 }
@@ skipping 30 matching lines @@
     stream = new AlsaPcmOutputStream(device_name, params, wrapper_.get(), this,
                                      GetMessageLoop());
 #if defined(USE_PULSEAUDIO)
   }
 #endif
   active_streams_.insert(stream);
   return stream;
 }
 
 AudioInputStream* AudioManagerLinux::MakeAudioInputStream(
-    const AudioParameters& params) {
-  if (!params.IsValid() || params.channels > kMaxInputChannels)
+    const AudioParameters& params, const std::string& device_id) {
+  if (!params.IsValid() || params.channels > kMaxInputChannels ||
+      device_id.empty())
     return NULL;
 
   if (params.format == AudioParameters::AUDIO_MOCK) {
     return FakeAudioInputStream::MakeFakeStream(params);
   } else if (params.format != AudioParameters::AUDIO_PCM_LINEAR) {
     return NULL;
   }
 
   if (!initialized())
     return NULL;
 
-  // TODO(xians): Pass the device name From AudioInputController instead.
-  std::string device_name = AlsaPcmOutputStream::kAutoSelectDevice;
+  std::string device_name = (device_id == AudioManagerBase::kDefaultDeviceId) ?
+      AlsaPcmInputStream::kAutoSelectDevice : device_id;
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAlsaInputDevice)) {
     device_name = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
         switches::kAlsaInputDevice);
   }
 
   AlsaPcmInputStream* stream = new AlsaPcmInputStream(
       device_name, params, wrapper_.get());
 
   return stream;
 }
@@ skipping 61 matching lines @@
   DCHECK(device_names->empty());
 
   GetAlsaAudioInputDevices(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.
     // We use index 0 to make up the unique_id to identify the default device.
     device_names->push_front(media::AudioDeviceName(
-        AudioManagerBase::kDefaultDeviceName, "0"));
+        AudioManagerBase::kDefaultDeviceName,
+        AudioManagerBase::kDefaultDeviceId));
   }
 }
 
 void AudioManagerLinux::GetAlsaAudioInputDevices(
     media::AudioDeviceNames* device_names) {
   // Constants specified by the ALSA API for device hints.
   static const char kPcmInterfaceName[] = "pcm";
   int card = -1;
 
   // Loop through the sound cards to get ALSA device hints.
@@ skipping 52 matching lines @@
         name.device_name = unique_device_name.get();
       }
 
       // Store the device information.
       device_names->push_back(name);
     }
   }
 }
 
 bool AudioManagerLinux::IsAlsaDeviceAvailable(const char* device_name) {
+  static const char kNotWantedSurroundDevices[] = "surround";
+
   if (!device_name)
     return false;
 
   // Check if the device is in the list of invalid devices.
   for (size_t i = 0; i < arraysize(kInvalidAudioInputDevices); ++i) {
-    if (!strncmp(kInvalidAudioInputDevices[i], device_name,
-                 strlen(kInvalidAudioInputDevices[i])))
+    if ((strcmp(kInvalidAudioInputDevices[i], device_name) == 0) ||
+        (strncmp(kNotWantedSurroundDevices, device_name,
+            arraysize(kNotWantedSurroundDevices) - 1) == 0))
       return false;
   }
 
   // The only way to check if the device is available is to open/close the
   // device. Return false if it fails either of operations.
   snd_pcm_t* device_handle = NULL;
   if (wrapper_->PcmOpen(&device_handle,
                         device_name,
                         SND_PCM_STREAM_CAPTURE,
                         SND_PCM_NONBLOCK))
@@ skipping 41 matching lines @@
     }
   }
 
   return has_device;
 }
 
 // static
 AudioManager* AudioManager::CreateAudioManager() {
   return new AudioManagerLinux();
 }