Looking up device id by session id for AudioRendererMixerInput

content/renderer/media/audio_device_factory.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_device_factory.h"
 
 #include "base/logging.h"
 #include "content/renderer/media/audio_input_message_filter.h"
 #include "content/renderer/media/audio_message_filter.h"
 #include "content/renderer/media/audio_renderer_mixer_manager.h"
@@ skipping 29 matching lines @@
   if (source_type == AudioDeviceFactory::kSourceMediaElement)
     return true;  // Must ALWAYS go through mixer.
 
   // TODO(olka): make a decision for the rest of the sources basing on OS
   // type and configuration parameters.
   return false;
 }
 
 scoped_refptr<media::SwitchableAudioRendererSink> NewMixableSink(
     int render_frame_id,
+    int session_id,
     const std::string& device_id,
     const url::Origin& security_origin) {
   RenderThreadImpl* render_thread = RenderThreadImpl::current();
   return scoped_refptr<media::AudioRendererMixerInput>(
       render_thread->GetAudioRendererMixerManager()->CreateInput(
-          render_frame_id, device_id, security_origin));
+          render_frame_id, session_id, device_id, security_origin));
 }
 
 scoped_refptr<media::AudioRendererSink> NewUnmixableSink(
     int render_frame_id,
     int session_id,
     const std::string& device_id,
     const url::Origin& security_origin) {
   return NewOutputDevice(render_frame_id, session_id, device_id,
                          security_origin);
 }
@@ skipping 27 matching lines @@
   if (factory_) {
     scoped_refptr<media::AudioRendererSink> device =
         factory_->CreateAudioRendererSink(source_type, render_frame_id,
                                           session_id, device_id,
                                           security_origin);
     if (device)
       return device;
   }
 
   if (IsMixable(source_type))
-    return NewMixableSink(render_frame_id, device_id, security_origin);
+    return NewMixableSink(render_frame_id, session_id, device_id,
+                          security_origin);
 
   return NewUnmixableSink(render_frame_id, session_id, device_id,
                           security_origin);
 }
 
 // static
 scoped_refptr<media::SwitchableAudioRendererSink>
 AudioDeviceFactory::NewSwitchableAudioRendererSink(
     SourceType source_type,
     int render_frame_id,
     int session_id,
     const std::string& device_id,
     const url::Origin& security_origin) {
   if (factory_) {
     scoped_refptr<media::SwitchableAudioRendererSink> sink =
         factory_->CreateSwitchableAudioRendererSink(source_type,
                                                     render_frame_id, session_id,
                                                     device_id, security_origin);
     if (sink)
       return sink;
   }
 
   if (IsMixable(source_type))
-    return NewMixableSink(render_frame_id, device_id, security_origin);
+    return NewMixableSink(render_frame_id, session_id, device_id,
+                          security_origin);
 
   // AudioOutputDevice is not RestartableAudioRendererSink, so we can't return
   // anything for those who wants to create an unmixable sink.
   NOTIMPLEMENTED();
   return nullptr;
 }
 
 // static
 scoped_refptr<media::AudioCapturerSource>
 AudioDeviceFactory::NewAudioCapturerSource(int render_frame_id) {
@@ skipping 28 matching lines @@
 AudioDeviceFactory::AudioDeviceFactory() {
   DCHECK(!factory_) << "Can't register two factories at once.";
   factory_ = this;
 }
 
 AudioDeviceFactory::~AudioDeviceFactory() {
   factory_ = NULL;
 }
 
 }  // namespace content