Adding GetAudioInputDeviceNames to AudioManager, this function is supposed to do device enumerati...

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"
 #include "base/process_util.h"
+#include "base/stringprintf.h"
 #include "media/audio/audio_output_dispatcher.h"
 #include "media/audio/fake_audio_input_stream.h"
 #include "media/audio/fake_audio_output_stream.h"
 #include "media/audio/linux/alsa_input.h"
 #include "media/audio/linux/alsa_output.h"
 #include "media/audio/linux/alsa_wrapper.h"
 #include "media/base/limits.h"
 #include "media/base/media_switches.h"
 
 // Maximum number of output streams that can be open simultaneously.
 static const size_t kMaxOutputStreams = 50;
 
 static const int kMaxInputChannels = 2;
 
 // Implementation of AudioManager.
 bool AudioManagerLinux::HasAudioOutputDevices() {
   // TODO(ajwong): Make this actually query audio devices.
   return true;
 }
 
 bool AudioManagerLinux::HasAudioInputDevices() {
-  // TODO(satish): Make this actually query audio devices.
-  return true;
+  if (!initialized()) {
+    return false;
+  }
+
+  // Constants specified by the ALSA API for device hints.
+  static const int kGetAllDevices = -1;
+  static const char kPcmInterfaceName[] = "pcm";
+  bool has_device(false);
+  void **hints = NULL;
+
+  // Use the same approach to find the devices as in
+  // AlsaPcmOutputStream::FindDeviceForChannels
+  // Get Alsa device hints.
+  int error = wrapper_->DeviceNameHint(kGetAllDevices,
+                                       kPcmInterfaceName,
+                                       &hints);
+  if (error == 0) {

[awong, 2011/05/23 21:17:58]

If you invert the control flow, you can indeed early return on error, and not
need to worry about keeping an extra state variable.

[xians, 2011/05/24 13:50:27]

Hold until the details here are sorted out.
And I removed the comment to see if it is better to just get rid of it.

[awong, 2011/05/24 23:30:32]

Ah...I missed that hints might need to be freed.  I guess the API doesn't
guarantee that hints is not allocated on failure.

Looks fine as is then.

+    // NOTE: Do not early return from inside this if statement.  The

[awong, 2011/05/23 21:17:58]

I think you can clean up the control flow of this function now to not need this
NOTE.

[awong, 2011/05/24 23:30:32]

This comment is still out of date.

+    // hints above need to be freed.
+    has_device = HasAnyValidAudioInputDevice(hints);
+  } else {
+    LOG(ERROR) << "Unable to get device hints: " << wrapper_->StrError(error);
+  }
+
+  // Destory the hint now that we're done with it.
+  wrapper_->DeviceNameFreeHint(hints);
+  hints = NULL;

[awong, 2011/05/23 21:17:58]

not necesasry to reset a local to NULL.

[xians, 2011/05/24 13:50:27]

Done.

+  return has_device;
 }
 
 AudioOutputStream* AudioManagerLinux::MakeAudioOutputStream(
     AudioParameters params) {
   // Early return for testing hook.  Do this before checking for
   // |initialized_|.
   if (params.format == AudioParameters::AUDIO_MOCK) {
     return FakeAudioOutputStream::MakeFakeStream(params);
   }
 
@@ skipping 44 matching lines @@
   AlsaPcmInputStream* stream = new AlsaPcmInputStream(
       device_name, params, wrapper_.get());
 
   return stream;
 }
 
 AudioManagerLinux::AudioManagerLinux() {
 }
 
 AudioManagerLinux::~AudioManagerLinux() {
   // Make sure we stop the thread first. If we let the default destructor to

[awong, 2011/05/23 21:17:58]

"let the default destructor to destruct" -> "allow the default destructor to
destroy"

[xians, 2011/05/24 13:50:27]

Done.

   // destruct the members, we may destroy audio streams before stopping the
   // thread, resulting an unexpected behavior.
   // This way we make sure activities of the audio streams are all stopped
   // before we destroy them.
   audio_thread_.Stop();
 
   // Free output dispatchers, closing all remaining open streams.
   output_dispatchers_.clear();
 
   active_streams_.clear();
@@ skipping 30 matching lines @@
 
 void AudioManagerLinux::ShowAudioInputSettings() {
   scoped_ptr<base::Environment> env(base::Environment::Create());
   base::nix::DesktopEnvironment desktop = base::nix::GetDesktopEnvironment(
       env.get());
   std::string command((desktop == base::nix::DESKTOP_ENVIRONMENT_GNOME) ?
                       "gnome-volume-control" : "kmix");
   base::LaunchApp(CommandLine(FilePath(command)), false, false, NULL);
 }
 
+void AudioManagerLinux::GetAudioInputDeviceNames(
+    AudioDeviceNames* device_names) {
+  // TODO(xians): query a full list of valid devices.
+  if (HasAudioInputDevices()) {
+    // Add the default device to the list.
+    // We use (device_name)_(index) to make up the unique_ids to identify the
+    // devices. For default device, the index is 0, so its unique_id is
+    // Default_0.
+    AudioDeviceName name;
+    name.device_name = AudioManagerBase::kDefaultDeviceName;
+    name.unique_id = StringPrintf("%s_0", AudioManagerBase::kDefaultDeviceName);
+    device_names->push_back(name);
+  }
+}
+
+bool AudioManagerLinux::HasAnyValidAudioInputDevice(void** hints) {
+  static const char kIoHintName[] = "IOID";
+  static const char kNameHintName[] = "NAME";
+
+  // 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. Finally, output and
+  // null devices are not considered as valid devices for recording.
+  static const char kOutputDevice[] = "Output";
+  static const char KNotWantedDefaultDevice[] = "default";
+  static const char kNotWantedNullDevice[] = "null";
+  static const char kNotWantedPulseDevice[] = "pulse";
+  static const char kNotWantedDmixDevice[] = "dmix";
+  static const char kNotWantedSurroundDevice[] = "surround";
+
+  for (void** hint_iter = hints; *hint_iter != NULL; hint_iter++) {
+    // Only examine devices that are input capable..  Valid values are
+    // "Input", "Output", and NULL which means both input and output.
+    scoped_ptr_malloc<char> io(wrapper_->DeviceNameGetHint(*hint_iter,
+                                                           kIoHintName));
+    // Wrong device type, skip it.
+    if (io != NULL &&
+        strncmp(kOutputDevice, io.get(), strlen(kOutputDevice)) == 0)
+      continue;
+
+    scoped_ptr_malloc<char> hint_device_name(
+        wrapper_->DeviceNameGetHint(*hint_iter, kNameHintName));
+    // Now check if if it is a valid device.
+    if (hint_device_name != NULL &&
+        strncmp(KNotWantedDefaultDevice,
+                hint_device_name.get(),
+                strlen(KNotWantedDefaultDevice)) != 0 &&
+        strncmp(kNotWantedNullDevice,
+                hint_device_name.get(),
+                strlen(kNotWantedNullDevice)) != 0 &&
+        strncmp(kNotWantedPulseDevice,
+                hint_device_name.get(),
+                strlen(kNotWantedPulseDevice)) != 0 &&
+        strncmp(kNotWantedDmixDevice,
+                hint_device_name.get(),
+                strlen(kNotWantedDmixDevice)) != 0 &&
+        strncmp(kNotWantedSurroundDevice,
+                hint_device_name.get(),
+                strlen(kNotWantedSurroundDevice)) != 0) {
+      return true;
+    }
+  }
+
+  // Did not find a valid device
+  return false;
+}
+
 // static
 AudioManager* AudioManager::CreateAudioManager() {
   return new AudioManagerLinux();
 }