Implicit audio output device selection for getUserMedia.

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 16 matching lines @@
 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);
+                               44100, media::CHANNEL_LAYOUT_STEREO,
+                               0, 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));
@@ skipping 114 matching lines @@
                  this, stream_type, base::Passed(&devices)));
 }
 
 void AudioInputDeviceManager::OpenOnDeviceThread(
     int session_id, const StreamDeviceInfo& info) {
   SCOPED_UMA_HISTOGRAM_TIMER(
       "Media.AudioInputDeviceManager.OpenOnDeviceThreadTime");
   DCHECK(IsOnDeviceThread());
 
   StreamDeviceInfo out(info.device.type, info.device.name, info.device.id,
-                       0, 0, false);
+                       0, 0, 0, false);
   out.session_id = session_id;
+
+  MediaStreamDevice::AudioDeviceParameters& input_params = out.device.input;
+
   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;
+    input_params.sample_rate = 44100;
+    input_params.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();
+    input_params.sample_rate = params.sample_rate();
+    input_params.channel_layout = params.channel_layout();
+    input_params.frames_per_buffer = params.frames_per_buffer();
+
+    // Add preferred output device information if a matching output device
+    // exists.
+    out.device.matched_output_device_id =
+        audio_manager_->GetAssociatedOutputDeviceID(info.device.id);
+    if (!out.device.matched_output_device_id.empty()) {
+      params = audio_manager_->GetOutputStreamParameters(
+          out.device.matched_output_device_id);
+      MediaStreamDevice::AudioDeviceParameters& matched_output_params =
+          out.device.matched_output;
+      matched_output_params.sample_rate = params.sample_rate();
+      matched_output_params.channel_layout = params.channel_layout();
+      matched_output_params.frames_per_buffer = params.frames_per_buffer();
+    }
   }
 
   // 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(
     MediaStreamType stream_type,
     scoped_ptr<StreamDeviceInfoArray> devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // Ensure that |devices| gets deleted on exit.
   if (listener_)
     listener_->DevicesEnumerated(stream_type, *devices);
 }
 
 void AudioInputDeviceManager::OpenedOnIOThread(int session_id,
                                                const StreamDeviceInfo& info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK_EQ(session_id, info.session_id);
   DCHECK(GetDevice(session_id) == devices_.end());
+
   devices_.push_back(info);
 
   if (listener_)
     listener_->Opened(info.device.type, session_id);
 }
 
 void AudioInputDeviceManager::ClosedOnIOThread(MediaStreamType stream_type,
                                                int session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (listener_)
     listener_->Closed(stream_type, session_id);
 }
 
 bool AudioInputDeviceManager::IsOnDeviceThread() const {
   return device_loop_->BelongsToCurrentThread();
 }
 
 AudioInputDeviceManager::StreamDeviceList::iterator
 AudioInputDeviceManager::GetDevice(int session_id) {
   for (StreamDeviceList::iterator i(devices_.begin()); i != devices_.end();
        ++i) {
     if (i->session_id == session_id)
       return i;
   }
 
   return devices_.end();
 }
 
 }  // namespace content