Wait for the renderer even on WASAPI.

media/audio/audio_output_controller.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_controller.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/threading/platform_thread.h"
@@ skipping 255 matching lines @@
                                       AudioBuffersState buffers_state) {
   return OnMoreIOData(NULL, dest, buffers_state);
 }
 
 int AudioOutputController::OnMoreIOData(AudioBus* source,
                                         AudioBus* dest,
                                         AudioBuffersState buffers_state) {
   DisallowEntryToOnMoreIOData();
   TRACE_EVENT0("audio", "AudioOutputController::OnMoreIOData");
 
+  // The OS level audio APIs on Linux and Windows all have problems requesting
+  // data on a fixed interval.  Sometimes they will issue calls back to back
+  // which can cause glitching, so wait until the renderer is ready for Read().
+  //
+  // See many bugs for context behind this decision: http://crbug.com/170498,
+  // http://crbug.com/171651, http://crbug.com/174985, and more.
+#if defined(OS_WIN) || defined(OS_LINUX)
+  WaitTillDataReady();
+#endif
+
   const int frames = sync_reader_->Read(source, dest);
   DCHECK_LE(0, frames);
   sync_reader_->UpdatePendingBytes(
       buffers_state.total_bytes() + frames * params_.GetBytesPerFrame());
 
   AllowEntryToOnMoreIOData();
   return frames;
 }
 
 void AudioOutputController::WaitTillDataReady() {
   base::Time start = base::Time::Now();
-  // Wait for up to 1.5 seconds for DataReady().  1.5 seconds was chosen because
-  // it's larger than the playback time of the WaveOut buffer size using the
-  // minimum supported sample rate: 4096 / 3000 = ~1.4 seconds.  Even a client
-  // expecting real time playout should be able to fill in this time.
-  const base::TimeDelta max_wait = base::TimeDelta::FromMilliseconds(1500);
+  // Wait for up to 683ms for DataReady().  683ms was chosen because it's larger
+  // than the playback time of the WaveOut buffer size using the minimum
+  // supported sample rate: 2048 / 3000 = ~683ms.
+  const base::TimeDelta kMaxWait = base::TimeDelta::FromMilliseconds(683);
   while (!sync_reader_->DataReady() &&
-         ((base::Time::Now() - start) < max_wait)) {
+         ((base::Time::Now() - start) < kMaxWait)) {
     base::PlatformThread::YieldCurrentThread();
   }
 }
 
 void AudioOutputController::OnError(AudioOutputStream* stream, int code) {
   // Handle error on the audio controller thread.
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &AudioOutputController::DoReportError, this, code));
 }
 
@@ skipping 92 matching lines @@
   DCHECK(base::AtomicRefCountIsZero(&num_allowed_io_));
   base::AtomicRefCountInc(&num_allowed_io_);
 }
 
 void AudioOutputController::DisallowEntryToOnMoreIOData() {
   const bool is_zero = !base::AtomicRefCountDec(&num_allowed_io_);
   DCHECK(is_zero);
 }
 
 }  // namespace media