Looking up device id by session id for AudioRendererMixerInput

media/audio/audio_output_device.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 "media/audio/audio_output_device.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cmath>
@@ skipping 275 matching lines @@
         callback_->OnRenderError();
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 void AudioOutputDevice::OnDeviceAuthorized(
     OutputDeviceStatus device_status,
-    const media::AudioParameters& output_params) {
+    const media::AudioParameters& output_params,
+    const std::string& matched_device_id) {
   DCHECK(task_runner()->BelongsToCurrentThread());
   DCHECK_EQ(state_, AUTHORIZING);
 
   // It may happen that a second authorization is received as a result to a
   // call to Start() after Stop(). If the status for the second authorization
   // differs from the first, it will not be reflected in |device_status_|
   // to avoid a race.
   // This scenario is unlikely. If it occurs, the new value will be
   // different from OUTPUT_DEVICE_STATUS_OK, so the AudioOutputDevice
   // will enter the IPC_CLOSED state anyway, which is the safe thing to do.
   // This is preferable to holding a lock.
   if (!did_receive_auth_.IsSignaled())
     device_status_ = device_status;
 
   if (device_status == OUTPUT_DEVICE_STATUS_OK) {
     state_ = AUTHORIZED;
     if (!did_receive_auth_.IsSignaled()) {
       output_params_ = output_params;
       did_receive_auth_.Signal();
     }
     if (start_on_authorized_)
       CreateStreamOnIOThread(audio_parameters_);
+
+    // Matching can take place only if |session_id_| is specified and
+    // |device_id_| is not, however, it's possible not to have a matched device
+    // even in this case. It means |session_id_| failed and the default device

[Henrik Grunell, 2016/03/08 21:09:57]

What does "|session_id_| failed" mean?

[o1ka, 2016/04/05 15:13:38]

Done.

+    // is used.
+    DCHECK((session_id_ && device_id_.empty()) ? true
+                                               : matched_device_id_.empty());
+    matched_device_id_ = matched_device_id;

[o1ka, 2016/04/05 15:13:38]

This races with a getter: |matched_device_id_| should be set before
did_receive_auth_.Signal().

   } else {
     // Closing IPC forces a Signal(), so no clients are locked waiting
     // indefinitely after this method returns.
     ipc_->CloseStream();
     OnIPCClosed();
     if (callback_)
       callback_->OnRenderError();
   }
 }
 
@@ skipping 51 matching lines @@
 
   // Signal to unblock any blocked threads waiting for parameters
   did_receive_auth_.Signal();
 }
 
 void AudioOutputDevice::WillDestroyCurrentMessageLoop() {
   LOG(ERROR) << "IO loop going away before the audio device has been stopped";
   ShutDownOnIOThread();
 }
 
+std::string AudioOutputDevice::GetDeviceId() {
+  CHECK(!task_runner()->BelongsToCurrentThread());
+  did_receive_auth_.Wait();
+  return (device_id_.empty() && session_id_) ? matched_device_id_ : device_id_;
+}
+
 // AudioOutputDevice::AudioThreadCallback
 
 AudioOutputDevice::AudioThreadCallback::AudioThreadCallback(
     const AudioParameters& audio_parameters,
     base::SharedMemoryHandle memory,
     int memory_length,
     AudioRendererSink::RenderCallback* render_callback)
     : AudioDeviceThread::Callback(audio_parameters, memory, memory_length, 1),
       render_callback_(render_callback),
       callback_num_(0) {}
@@ skipping 41 matching lines @@
 
   // Update the audio-delay measurement, inform about the number of skipped
   // frames, and ask client to render audio.  Since |output_bus_| is wrapping
   // the shared memory the Render() call is writing directly into the shared
   // memory.
   render_callback_->Render(output_bus_.get(), std::round(frames_delayed),
                            frames_skipped);
 }
 
 }  // namespace media