Reland 15721002: Hook up the device selection to the WebAudio live audio

content/browser/renderer_host/media/audio_input_device_manager.cc

 // 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 "content/browser/renderer_host/media/audio_input_device_manager.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/media_stream_request.h"
@@ skipping 11 matching lines @@
 // Starting id for the first capture session.
 const int kFirstSessionId = AudioInputDeviceManager::kFakeOpenSessionId + 1;
 }
 
 AudioInputDeviceManager::AudioInputDeviceManager(
     media::AudioManager* audio_manager)
     : listener_(NULL),
       next_capture_session_id_(kFirstSessionId),
       use_fake_device_(false),
       audio_manager_(audio_manager) {
+  // TODO(xians): Remove this fake_device after the unittests do not need it.
+  StreamDeviceInfo fake_device(MEDIA_DEVICE_AUDIO_CAPTURE,
+                               media::AudioManagerBase::kDefaultDeviceName,
+                               media::AudioManagerBase::kDefaultDeviceId,
+                               44100, media::CHANNEL_LAYOUT_STEREO, false);
+  fake_device.session_id = kFakeOpenSessionId;
+  devices_.push_back(fake_device);
 }
 
 AudioInputDeviceManager::~AudioInputDeviceManager() {
 }
 
 const StreamDeviceInfo* AudioInputDeviceManager::GetOpenedDeviceInfoById(
     int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   StreamDeviceList::iterator device = GetDevice(session_id);
   if (device == devices_.end())
@@ skipping 39 matching lines @@
   return session_id;
 }
 
 void AudioInputDeviceManager::Close(int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(listener_);
   StreamDeviceList::iterator device = GetDevice(session_id);
   if (device == devices_.end())
     return;
   const MediaStreamType stream_type = device->device.type;
-  devices_.erase(device);
+  if (session_id != kFakeOpenSessionId)
+    devices_.erase(device);
 
   // Post a callback through the listener on IO thread since
   // MediaStreamManager is expecting the callback asynchronously.
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&AudioInputDeviceManager::ClosedOnIOThread,
                                      this, stream_type, session_id));
 }
 
 void AudioInputDeviceManager::UseFakeDevice() {
@@ skipping 25 matching lines @@
   }
 
   scoped_ptr<StreamDeviceInfoArray> devices(new StreamDeviceInfoArray());
   for (media::AudioDeviceNames::iterator it = device_names.begin();
        it != device_names.end(); ++it) {
     // Add device information to device vector.
     devices->push_back(StreamDeviceInfo(
         stream_type, it->device_name, it->unique_id, false));
   }
 
+  // If the |use_fake_device_| flag is on, inject the fake device if there is
+  // no available device on the OS.
+  if (use_fake_device_ && devices->empty()) {
+    devices->push_back(StreamDeviceInfo(
+        stream_type, media::AudioManagerBase::kDefaultDeviceName,
+        media::AudioManagerBase::kDefaultDeviceId, false));
+  }
+
   // Return the device list through the listener by posting a task on
   // IO thread since MediaStreamManager handles the callback asynchronously.
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&AudioInputDeviceManager::DevicesEnumeratedOnIOThread,
                  this, stream_type, base::Passed(&devices)));
 }
 
 void AudioInputDeviceManager::OpenOnDeviceThread(
     int session_id, const StreamDeviceInfo& info) {
   DCHECK(IsOnDeviceThread());
 
-  // Get the preferred sample rate and channel configuration for the
-  // audio device.
-  media::AudioParameters params =
-      audio_manager_->GetInputStreamParameters(info.device.id);
-
   StreamDeviceInfo out(info.device.type, info.device.name, info.device.id,
-                       params.sample_rate(), params.channel_layout(), false);
+                       0, 0, false);
   out.session_id = session_id;
+  if (use_fake_device_) {
+    // Don't need to query the hardware information if using fake device.
+    out.device.sample_rate = 44100;
+    out.device.channel_layout = media::CHANNEL_LAYOUT_STEREO;
+  } else {
+    // Get the preferred sample rate and channel configuration for the
+    // audio device.
+    media::AudioParameters params =
+        audio_manager_->GetInputStreamParameters(info.device.id);
+    out.device.sample_rate = params.sample_rate();
+    out.device.channel_layout = params.channel_layout();
+  }
 
   // Return the |session_id| through the listener by posting a task on
   // IO thread since MediaStreamManager handles the callback asynchronously.
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&AudioInputDeviceManager::OpenedOnIOThread,
                                      this, session_id, out));
 }
 
 void AudioInputDeviceManager::DevicesEnumeratedOnIOThread(
@@ skipping 32 matching lines @@
   for (StreamDeviceList::iterator i(devices_.begin()); i != devices_.end();
        ++i) {
     if (i->session_id == session_id)
       return i;
   }
 
   return devices_.end();
 }
 
 }  // namespace content