Looking up device id by session id for AudioRendererMixerInput

content/renderer/media/audio_renderer_mixer_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/renderer/media/audio_renderer_mixer_manager.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "build/build_config.h"
 #include "content/renderer/media/audio_device_factory.h"
-#include "media/audio/audio_output_device.h"
+#include "media/audio/audio_manager_base.h"
 #include "media/base/audio_hardware_config.h"
 #include "media/base/audio_renderer_mixer.h"
 #include "media/base/audio_renderer_mixer_input.h"
 
 namespace content {
 
 AudioRendererMixerManager::AudioRendererMixerManager() {}
 
 AudioRendererMixerManager::~AudioRendererMixerManager() {
   // References to AudioRendererMixers may be owned by garbage collected
   // objects.  During process shutdown they may be leaked, so, transitively,
   // |mixers_| may leak (i.e., may be non-empty at this time) as well.
 }
 
 media::AudioRendererMixerInput* AudioRendererMixerManager::CreateInput(
     int source_render_frame_id,
+    int session_id,
     const std::string& device_id,
     const url::Origin& security_origin) {
+  std::string new_device_id(device_id);

[Guido Urdaneta, 2016/04/07 11:14:28]

We can avoid this string copy.
The code will be slightly less clean, but I think it would be worth it.

[o1ka, 2016/04/07 12:40:49]

Done.

+
+  if (media::AudioManagerBase::UseSessionIdToSelectDevice(session_id,
+                                                          device_id)) {
+    // Output sink should be selected basing on |session_id|
+    scoped_refptr<media::AudioRendererSink> sink_from_session_id =
+        AudioDeviceFactory::NewAudioRendererMixerSink(
+            source_render_frame_id, session_id, device_id, security_origin);
+    new_device_id = sink_from_session_id->GetOutputDeviceInfo().device_id();
+
+    // TODO(olka): Cache it and reuse, http://crbug.com/586161
+    sink_from_session_id->Stop();
+  }
+
+  // At this point the output device is represented by |new_device_id| and
+  // |session_id| can (and should) be safely ignored.
   return new media::AudioRendererMixerInput(
       base::Bind(&AudioRendererMixerManager::GetMixer, base::Unretained(this),
                  source_render_frame_id),
       base::Bind(&AudioRendererMixerManager::RemoveMixer,
                  base::Unretained(this), source_render_frame_id),
-      device_id,
-      security_origin);
+      new_device_id, security_origin);
 }
 
 media::AudioRendererMixer* AudioRendererMixerManager::GetMixer(
     int source_render_frame_id,
     const media::AudioParameters& params,
     const std::string& device_id,
     const url::Origin& security_origin,
     media::OutputDeviceStatus* device_status) {
   // Effects are not passed through to output creation, so ensure none are set.
   DCHECK_EQ(params.effects(), media::AudioParameters::NO_EFFECTS);
@@ skipping 83 matching lines @@
     const std::string& device_id,
     const url::Origin& security_origin)
     : source_render_frame_id(source_render_frame_id),
       params(params),
       device_id(device_id),
       security_origin(security_origin) {}
 
 AudioRendererMixerManager::MixerKey::MixerKey(const MixerKey& other) = default;
 
 }  // namespace content