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

content/renderer/media/audio_input_device.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 "content/renderer/media/audio_input_device.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "content/common/child_process.h"
 #include "content/common/media/audio_messages.h"
 #include "content/common/view_messages.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/audio/audio_util.h"
 
+static const char kDefaultDeviceUId[] = "default";

[scherkus (not reviewing), 2011/11/16 01:20:40]

I don't see this used and it's also confusing with the code change below where
you pass in "" as default

[no longer working on chromium, 2011/11/16 17:45:48]

Sorry, wrong code by mistake.

+
 AudioInputDevice::AudioInputDevice(size_t buffer_size,
                                    int channels,
                                    double sample_rate,
                                    CaptureCallback* callback,
                                    CaptureEventHandler* event_handler)
     : callback_(callback),
       event_handler_(event_handler),
       audio_delay_milliseconds_(0),
       volume_(1.0),
       stream_id_(0),
@@ skipping 93 matching lines @@
   // Make sure we don't call Start() more than once.
   DCHECK_EQ(0, stream_id_);
   if (stream_id_)
     return;
 
   stream_id_ = filter_->AddDelegate(this);
   // If |session_id_| is not specified, it will directly create the stream;
   // otherwise it will send a AudioInputHostMsg_StartDevice msg to the browser
   // and create the stream when getting a OnDeviceReady() callback.
   if (!session_id_) {
+    // Pass an empty string to indicate using default device.
+    std::string default_device_uid = "";
     Send(new AudioInputHostMsg_CreateStream(stream_id_, audio_parameters_,
-                                            true));
+                                            true, default_device_uid));
   } else {
     Send(new AudioInputHostMsg_StartDevice(stream_id_, session_id_));
     pending_device_ready_ = true;
   }
 }
 
 void AudioInputDevice::SetSessionIdOnIOThread(int session_id) {
   DCHECK(MessageLoop::current() == ChildProcess::current()->io_message_loop());
   session_id_ = session_id;
 }
@@ skipping 98 matching lines @@
       break;
     case kAudioStreamError:
       DLOG(WARNING) << "AudioInputDevice::OnStateChanged(kError)";
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
-void AudioInputDevice::OnDeviceReady(int index) {
+void AudioInputDevice::OnDeviceReady(const std::string& device_uid) {
   DCHECK(MessageLoop::current() == ChildProcess::current()->io_message_loop());
-  VLOG(1) << "OnDeviceReady (index=" << index << ")";
+  VLOG(1) << "OnDeviceReady (device_uid=" << device_uid << ")";
 
   // Takes care of the case when Stop() is called before OnDeviceReady().
   if (!pending_device_ready_)
     return;
 
-  // -1 means no device has been started.
-  if (index == -1) {
+  // If AudioInputDeviceManager returns an empty string, it means no device
+  // is ready for start.
+  if (device_uid.empty()) {
     filter_->RemoveDelegate(stream_id_);
     stream_id_ = 0;
   } else {
     Send(new AudioInputHostMsg_CreateStream(
-        stream_id_, audio_parameters_, true));
+        stream_id_, audio_parameters_, true, device_uid));
   }
 
   pending_device_ready_ = false;
   // Notify the client that the device has been started.
   if (event_handler_)
-    event_handler_->OnDeviceStarted(index);
+    event_handler_->OnDeviceStarted(device_uid);
 }
 
 void AudioInputDevice::Send(IPC::Message* message) {
   filter_->Send(message);
 }
 
 // Our audio thread runs here. We receive captured audio samples on
 // this thread.
 void AudioInputDevice::Run() {
   audio_thread_->SetThreadPriority(base::kThreadPriority_RealtimeAudio);
@@ skipping 39 matching lines @@
                                     bytes_per_sample,
                                     number_of_frames);
   }
 
   // Deliver captured data to the client in floating point format
   // and update the audio-delay measurement.
   callback_->Capture(audio_data_,
                      number_of_frames,
                      audio_delay_milliseconds_);
 }