Implicit audio output device selection for getUserMedia.

content/browser/renderer_host/media/audio_renderer_host.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_renderer_host.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/memory/shared_memory.h"
@@ skipping 18 matching lines @@
 
 namespace content {
 
 class AudioRendererHost::AudioEntry
     : public media::AudioOutputController::EventHandler {
  public:
   AudioEntry(AudioRendererHost* host,
              int stream_id,
              int render_view_id,
              const media::AudioParameters& params,
+             const std::string& output_device_id,
              const std::string& input_device_id,
              scoped_ptr<base::SharedMemory> shared_memory,
              scoped_ptr<media::AudioOutputController::SyncReader> reader);
   virtual ~AudioEntry();
 
   int stream_id() const {
     return stream_id_;
   }
 
   int render_view_id() const {
@@ skipping 32 matching lines @@
   // Shared memory for transmission of the audio data.
   const scoped_ptr<base::SharedMemory> shared_memory_;
 
   // The synchronous reader to be used by the controller.
   const scoped_ptr<media::AudioOutputController::SyncReader> reader_;
 };
 
 AudioRendererHost::AudioEntry::AudioEntry(
     AudioRendererHost* host, int stream_id, int render_view_id,
     const media::AudioParameters& params,
+    const std::string& output_device_id,
     const std::string& input_device_id,
     scoped_ptr<base::SharedMemory> shared_memory,
     scoped_ptr<media::AudioOutputController::SyncReader> reader)
     : host_(host),
       stream_id_(stream_id),
       render_view_id_(render_view_id),
       controller_(media::AudioOutputController::Create(
-          // TODO(tommi): Feed in the proper output device id.
-          host->audio_manager_, this, params, std::string(),
+          host->audio_manager_, this, params, output_device_id,
           input_device_id, reader.get())),
       shared_memory_(shared_memory.Pass()),
       reader_(reader.Pass()) {
   DCHECK(controller_.get());
 }
 
 AudioRendererHost::AudioEntry::~AudioEntry() {}
 
 ///////////////////////////////////////////////////////////////////////////////
 // AudioRendererHost implementations.
@@ skipping 186 matching lines @@
   int input_channels = params.input_channels();
   if (input_channels < 0 ||
       input_channels > media::limits::kMaxChannels ||
       LookupById(stream_id) != NULL) {
     SendErrorMessage(stream_id);
     return;
   }
 
   // When the |input_channels| is valid, clients are trying to create a unified
   // IO stream which opens an input device mapping to the |session_id|.
-  std::string input_device_id;
+  // Initialize the |output_device_id| to an empty string which indicates that
+  // the default device should be used. If a StreamDeviceInfo instance was found
+  // though, then we use the matched output device.
+  std::string input_device_id, output_device_id;
+  const StreamDeviceInfo* info = media_stream_manager_->
+      audio_input_device_manager()->GetOpenedDeviceInfoById(session_id);
+  if (info)
+    output_device_id = info->device.matched_output_device_id;
+
   if (input_channels > 0) {
-    const StreamDeviceInfo* info = media_stream_manager_->
-        audio_input_device_manager()->GetOpenedDeviceInfoById(session_id);
     if (!info) {
       SendErrorMessage(stream_id);
       DLOG(WARNING) << "No permission has been granted to input stream with "
                     << "session_id=" << session_id;
       return;
     }
 
     input_device_id = info->device.id;
   }
 
@@ skipping 21 matching lines @@
     SendErrorMessage(stream_id);
     return;
   }
 
   MediaObserver* const media_observer =
       GetContentClient()->browser()->GetMediaObserver();
   if (media_observer)
     media_observer->OnCreatingAudioStream(render_process_id_, render_view_id);
 
   scoped_ptr<AudioEntry> entry(new AudioEntry(
-      this, stream_id, render_view_id, params, input_device_id,
-      shared_memory.Pass(),
+      this, stream_id, render_view_id, params, output_device_id,
+      input_device_id, shared_memory.Pass(),
       reader.PassAs<media::AudioOutputController::SyncReader>()));
   if (mirroring_manager_) {
     mirroring_manager_->AddDiverter(
         render_process_id_, entry->render_view_id(), entry->controller());
   }
   audio_entries_.insert(std::make_pair(stream_id, entry.release()));
   if (media_internals_) {
     media_internals_->OnAudioStreamCreated(
         this, stream_id, params, input_device_id);
   }
@@ skipping 109 matching lines @@
 }
 
 AudioRendererHost::AudioEntry* AudioRendererHost::LookupById(int stream_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   AudioEntryMap::const_iterator i = audio_entries_.find(stream_id);
   return i != audio_entries_.end() ? i->second : NULL;
 }
 
 }  // namespace content