Change GetVolume() to be asynchronous when being called by pulse thread

media/audio/pulse/pulse_input.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/pulse/pulse_input.h"
 
 #include <pulse/pulseaudio.h>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 199 matching lines @@
   pa_cvolume pa_volume;
   pa_cvolume_set(&pa_volume, channels_, volume);
   operation = pa_context_set_source_volume_by_index(
       pa_context_, index, &pa_volume, NULL, NULL);
 
   // Don't need to wait for this task to complete.
   pa_operation_unref(operation);
 }
 
 double PulseAudioInputStream::GetVolume() {
-  AutoPulseLock auto_lock(pa_mainloop_);
-  if (!handle_)
+  if (pa_threaded_mainloop_in_thread(pa_mainloop_)) {
+    // When being called by the pulse thread, GetVolume() is asynchronous and
+    // called under AutoPulseLock.
+    if (!handle_)
+      return 0.0;
+
+    size_t index = pa_stream_get_device_index(handle_);
+    pa_operation* operation = pa_context_get_source_info_by_index(
+        pa_context_, index, &VolumeCallback, this);
+    // Do not wait for the operation since we can't block the pulse thread.
+    pa_operation_unref(operation);
+
+    // Return zero and the callback will asynchronously update the |volume_|.
     return 0.0;
+  } else {
+    // Called by other thread, put an AutoPulseLock and wait for the operation.
+    AutoPulseLock auto_lock(pa_mainloop_);
+    if (!handle_)
+      return 0.0;
 
-  size_t index = pa_stream_get_device_index(handle_);
-  pa_operation* operation = pa_context_get_source_info_by_index(
-      pa_context_, index, &VolumeCallback, this);
-  WaitForOperationCompletion(pa_mainloop_, operation);
+    size_t index = pa_stream_get_device_index(handle_);
+    pa_operation* operation = pa_context_get_source_info_by_index(
+        pa_context_, index, &VolumeCallback, this);
+    WaitForOperationCompletion(pa_mainloop_, operation);
 
-  return volume_;
+    return volume_;
+  }
 }
 
 // static, used by pa_stream_set_read_callback.
 void PulseAudioInputStream::ReadCallback(pa_stream* handle,
                                          size_t length,
                                          void* user_data) {
   PulseAudioInputStream* stream =
       reinterpret_cast<PulseAudioInputStream*>(user_data);
 
   stream->ReadData();
@@ skipping 14 matching lines @@
   if (stream->channels_ != info->channel_map.channels)
     stream->channels_ = info->channel_map.channels;
 
   pa_volume_t volume = PA_VOLUME_MUTED; // Minimum possible value.
   // Use the max volume of any channel as the volume.
   for (int i = 0; i < stream->channels_; ++i) {
     if (volume < info->volume.values[i])
       volume = info->volume.values[i];
   }
 
+  // It is safe to access |volume_| here since VolumeCallback() is running
+  // under PulseLock.
   stream->volume_ = static_cast<double>(volume);
 }
 
 // static, used by pa_stream_set_state_callback.
 void PulseAudioInputStream::StreamNotifyCallback(pa_stream* s,
                                                  void* user_data) {
   PulseAudioInputStream* stream =
       reinterpret_cast<PulseAudioInputStream*>(user_data);
   if (s && stream->callback_ &&
       pa_stream_get_state(s) == PA_STREAM_FAILED) {
     stream->callback_->OnError(stream, pa_context_errno(stream->pa_context_));
   }
 
   pa_threaded_mainloop_signal(stream->pa_mainloop_, 0);
 }
 
 void PulseAudioInputStream::ReadData() {
   uint32 hardware_delay = pulse::GetHardwareLatencyInBytes(
       handle_, params_.sample_rate(), params_.GetBytesPerFrame());
 
   // Update the AGC volume level once every second. Note that,
   // |volume| is also updated each time SetVolume() is called
   // through IPC by the render-side AGC.
+  // QueryAgcVolume() will trigger a callback to asynchronously update the
+  // |volume_|, we disregard the |normalized_volume| from QueryAgcVolume()
+  // and use the value calculated by |volume_|.
   double normalized_volume = 0.0;
   QueryAgcVolume(&normalized_volume);
+  normalized_volume = volume_ / GetMaxVolume();
 
   do {
     size_t length = 0;
     const void* data = NULL;
     pa_stream_peek(handle_, &data, &length);
     if (!data || length == 0)
       break;
 
     buffer_->Append(reinterpret_cast<const uint8*>(data), length);
 
@@ skipping 15 matching lines @@
     DLOG(WARNING) << "OnData is being called consecutively, sleep 5ms to "
                   << "wait until render consumes the data";
     base::PlatformThread::Sleep(
         base::TimeDelta::FromMilliseconds(5));
   }
 
   pa_threaded_mainloop_signal(pa_mainloop_, 0);
 }
 
 }  // namespace media