remove the race related to output_delay_ms_ in ADM and races in the unittests.

content/renderer/media/webrtc_audio_device_impl.cc

 // Copyright (c) 2011 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/webrtc_audio_device_impl.h"
 
 #include "base/bind.h"
 #include "base/string_util.h"
 #include "base/win/windows_version.h"
 #include "content/renderer/media/audio_hardware.h"
@@ skipping 47 matching lines @@
   }
   return ret;
 }
 
 void WebRtcAudioDeviceImpl::Render(
     const std::vector<float*>& audio_data,
     size_t number_of_frames,
     size_t audio_delay_milliseconds) {
   DCHECK_LE(number_of_frames, output_buffer_size_);
 
-  // Store the reported audio delay locally.
-  output_delay_ms_ = audio_delay_milliseconds;
+  {
+    base::AutoLock auto_lock(lock_);
+    // Store the reported audio delay locally.
+    output_delay_ms_ = audio_delay_milliseconds;
+  }
 
   const int channels = audio_data.size();
   DCHECK_LE(channels, output_channels_);
 
   int samples_per_sec = static_cast<int>(output_sample_rate_);
   if (samples_per_sec == 44100) {
     // Even if the hardware runs at 44.1kHz, we use 44.0 internally.
     samples_per_sec = 44000;
   }
   uint32_t samples_per_10_msec = (samples_per_sec / 100);
@@ skipping 34 matching lines @@
 }
 
 void WebRtcAudioDeviceImpl::Capture(
     const std::vector<float*>& audio_data,
     size_t number_of_frames,
     size_t audio_delay_milliseconds) {
   DCHECK_LE(number_of_frames, input_buffer_size_);
 
   // Store the reported audio delay locally.
   input_delay_ms_ = audio_delay_milliseconds;
+  int output_delay_ms = 0;
+  {
+    base::AutoLock auto_lock(lock_);
+    output_delay_ms = output_delay_ms_;
+  }
 
   const int channels = audio_data.size();
   DCHECK_LE(channels, input_channels_);
   uint32_t new_mic_level = 0;
 
   // Interleave, scale, and clip input to int16 and store result in
   // a local byte buffer.
   media::InterleaveFloatToInt16(audio_data,
                                 input_buffer_.get(),
                                 number_of_frames);
@@ skipping 15 matching lines @@
   // buffer is empty.
   while (accumulated_audio_samples < number_of_frames) {
     // Deliver 10ms of recorded PCM audio.
     // TODO(henrika): add support for analog AGC?
     audio_transport_callback_->RecordedDataIsAvailable(
         audio_byte_buffer,
         samples_per_10_msec,
         bytes_per_sample_,
         channels,
         samples_per_sec,
-        input_delay_ms_ + output_delay_ms_,
+        input_delay_ms_ + output_delay_ms,
         0,  // clock_drift
         0,  // current_mic_level
         new_mic_level);  // not used
     accumulated_audio_samples += samples_per_10_msec;
     audio_byte_buffer += bytes_per_10_msec;
   }
 }
 
 void WebRtcAudioDeviceImpl::OnDeviceStarted(const std::string& device_id) {
   VLOG(1) << "OnDeviceStarted (device_id=" << device_id << ")";
@@ skipping 420 matching lines @@
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::StopPlayout() {
   DVLOG(1) << "StopPlayout()";
   DCHECK(audio_output_device_);
   if (!playing_) {
     // webrtc::VoiceEngine assumes that it is OK to call Stop() just in case.
     return 0;
   }
-  playing_ = !audio_output_device_->Stop();
-  return (!playing_ ? 0 : -1);
+  audio_output_device_->Stop();
+  playing_ = false;
+  return 0;
 }
 
 bool WebRtcAudioDeviceImpl::Playing() const {
   return playing_;
 }
 
 int32_t WebRtcAudioDeviceImpl::StartRecording() {
   DVLOG(1) << "StartRecording()";
 #if defined(OS_MACOSX)
   DLOG(WARNING) << "Real-time recording is not yet fully supported on Mac OS X";
@@ skipping 22 matching lines @@
   audio_input_device_->SetDevice(session_id_);
   audio_input_device_->Start();
   recording_ = true;
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::StopRecording() {
   DVLOG(1) << "StopRecording()";
   DCHECK(audio_input_device_);
 
-  base::AutoLock auto_lock(lock_);
-  if (!recording_) {
-    // webrtc::VoiceEngine assumes that it is OK to call Stop() just in case.
-    return 0;
+  {
+    base::AutoLock auto_lock(lock_);
+    if (!recording_) {
+      // webrtc::VoiceEngine assumes that it is OK to call Stop() just in case.
+      return 0;
+    }
   }
-  recording_ = !audio_input_device_->Stop();
-  return (!recording_ ? 0 : -1);
+
+  audio_input_device_->Stop();
+
+  {

[tommi (sloooow) - chröme, 2011/12/05 13:41:04]

nit: no need for this scope

[no longer working on chromium, 2011/12/09 09:48:19]

Done.

+    base::AutoLock auto_lock(lock_);
+    recording_ = false;
+  }
+  return 0;
 }
 
 bool WebRtcAudioDeviceImpl::Recording() const {
   return recording_;
 }
 
 int32_t WebRtcAudioDeviceImpl::SetAGC(bool enable) {
   DVLOG(2) << "WARNING: WebRtcAudioDeviceImpl::SetAGC() " << "NOT IMPLEMENTED";
   return -1;
 }
@@ skipping 220 matching lines @@
 }
 
 int32_t WebRtcAudioDeviceImpl::PlayoutBuffer(BufferType* type,
                                              uint16_t* size_ms) const {
   NOTIMPLEMENTED();
   return -1;
 }
 
 int32_t WebRtcAudioDeviceImpl::PlayoutDelay(uint16_t* delay_ms) const {
   // Report the cached output delay value.
+  base::AutoLock auto_lock(lock_);
   *delay_ms = static_cast<uint16_t>(output_delay_ms_);
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::RecordingDelay(uint16_t* delay_ms) const {
   // Report the cached output delay value.
   *delay_ms = static_cast<uint16_t>(input_delay_ms_);

[henrika (OOO until Aug 14), 2011/12/05 13:56:24]

Why no lock here?

[no longer working on chromium, 2011/12/09 09:48:19]

We don't use RecordingDelay() now, but I can add it anyway.

[no longer working on chromium, 2011/12/09 09:48:19]

Done.

   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::CPULoad(uint16_t* load) const {
   NOTIMPLEMENTED();
   return -1;
 }
 
 int32_t WebRtcAudioDeviceImpl::StartRawOutputFileRecording(
     const char pcm_file_name_utf8[webrtc::kAdmMaxFileNameSize]) {
@@ skipping 56 matching lines @@
 }
 
 int32_t WebRtcAudioDeviceImpl::GetLoudspeakerStatus(bool* enabled) const {
   NOTIMPLEMENTED();
   return -1;
 }
 
 void WebRtcAudioDeviceImpl::SetSessionId(int session_id) {
   session_id_ = session_id;
 }