Looking up device id by session id for AudioRendererMixerInput

content/renderer/media/audio_renderer_mixer_manager.h

 // 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.
 
 #ifndef CONTENT_RENDERER_MEDIA_AUDIO_RENDERER_MIXER_MANAGER_H_
 #define CONTENT_RENDERER_MEDIA_AUDIO_RENDERER_MIXER_MANAGER_H_
 
 #include <map>
 #include <string>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/synchronization/lock.h"
 #include "content/common/content_export.h"
+#include "media/audio/audio_manager_base.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/output_device_info.h"
 #include "url/origin.h"
 
 namespace media {
 class AudioHardwareConfig;
 class AudioRendererMixer;
 class AudioRendererMixerInput;
 class AudioRendererSink;
 }
@@ skipping 15 matching lines @@
 // via the shared memory.  See http://crbug.com/114700.
 class CONTENT_EXPORT AudioRendererMixerManager {
  public:
   AudioRendererMixerManager();
   ~AudioRendererMixerManager();
 
   // Creates an AudioRendererMixerInput with the proper callbacks necessary to
   // retrieve an AudioRendererMixer instance from AudioRendererMixerManager.
   // |source_render_frame_id| refers to the RenderFrame containing the entity
   // rendering the audio.  Caller must ensure AudioRendererMixerManager outlives
-  // the returned input. |device_id| and |security_origin| identify the output
-  // device to use
+  // the returned input. |device_id|, |session_id| and |security_origin|
+  // identify the output device to use. If |device_id| is empty and |session_id|
+  // is nonzero, output device associated with the opened input device
+  // designated by |session_id| is used. Otherwise, |session_id| is ignored.
   media::AudioRendererMixerInput* CreateInput(
       int source_render_frame_id,
+      int session_id,
       const std::string& device_id,
       const url::Origin& security_origin);
 
   // Returns a mixer instance based on AudioParameters; an existing one if one
   // with the provided AudioParameters exists or a new one if not.
   media::AudioRendererMixer* GetMixer(int source_render_frame_id,
                                       const media::AudioParameters& params,
                                       const std::string& device_id,
                                       const url::Origin& security_origin,
                                       media::OutputDeviceStatus* device_status);
@@ skipping 31 matching lines @@
         return a.source_render_frame_id < b.source_render_frame_id;
       if (a.params.channels() != b.params.channels())
         return a.params.channels() < b.params.channels();
 
       // Ignore effects(), bits_per_sample(), format(), and frames_per_buffer(),
       // these parameters do not affect mixer reuse.  All AudioRendererMixer
       // units disable FIFO, so frames_per_buffer() can be safely ignored.
       if (a.params.channel_layout() != b.params.channel_layout())
         return a.params.channel_layout() < b.params.channel_layout();
 
+      if (media::AudioManagerBase::IsDefaultDeviceId(a.device_id) &&
+          media::AudioManagerBase::IsDefaultDeviceId(b.device_id)) {
+        // Both device IDs represent the same default device => do not compare
+        // them; the default device is always authorized => ignoring security
+        // origin.
+        return false;
+      }
+
       if (a.device_id != b.device_id)
         return a.device_id < b.device_id;
 
       return a.security_origin < b.security_origin;
     }
   };
 
   // Map of MixerKey to <AudioRendererMixer, Count>.  Count allows
   // AudioRendererMixerManager to keep track explicitly (v.s. RefCounted which
   // is implicit) of the number of outstanding AudioRendererMixers.
   struct AudioRendererMixerReference {
     media::AudioRendererMixer* mixer;
     int ref_count;
   };
   typedef std::map<MixerKey, AudioRendererMixerReference, MixerKeyCompare>
       AudioRendererMixerMap;
 
   // Active mixers.
   AudioRendererMixerMap mixers_;
   base::Lock mixers_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioRendererMixerManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_AUDIO_RENDERER_MIXER_MANAGER_H_