Use 2 buffers on presumable good Windows boxes.

media/audio/audio_output_mixer.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_mixer.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 29 matching lines @@
     return true;
   AudioOutputStream* stream = audio_manager_->MakeAudioOutputStream(params_);
   if (!stream)
     return false;
   if (!stream->Open()) {
     stream->Close();
     return false;
   }
   pending_bytes_ = 0;  // Just in case.
   physical_stream_.reset(stream);
+  physical_stream_->SetVolume(1.0);
+  physical_stream_->Start(this);
   close_timer_.Reset();
   return true;
 }
 
 bool AudioOutputMixer::StartStream(
     AudioOutputStream::AudioSourceCallback* callback,
     AudioOutputProxy* stream_proxy) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   // May need to re-open the physical stream if no active proxies and
   // enough time had pass.
   OpenStream();
   if (!physical_stream_.get())
     return false;
 
   double volume = 0.0;
   stream_proxy->GetVolume(&volume);
-  bool should_start = proxies_.empty();
-  {
-    base::AutoLock lock(lock_);
-    ProxyData* proxy_data = &proxies_[stream_proxy];
-    proxy_data->audio_source_callback = callback;
-    proxy_data->volume = volume;
-    proxy_data->pending_bytes = 0;
-  }
-  // We cannot start physical stream under the lock,
-  // OnMoreData() would try acquiring it...
-  if (should_start) {
-    physical_stream_->SetVolume(1.0);
-    physical_stream_->Start(this);
-  }
+
+  base::AutoLock lock(lock_);
+  ProxyData* proxy_data = &proxies_[stream_proxy];
+  proxy_data->audio_source_callback = callback;
+  proxy_data->volume = volume;
+  proxy_data->pending_bytes = 0;
   return true;
 }
 
 void AudioOutputMixer::StopStream(AudioOutputProxy* stream_proxy) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
-  // Because of possible deadlock we cannot stop physical stream under the lock
-  // (physical_stream_->Stop() can call OnError(), and it acquires the lock to
-  // iterate through proxies), so acquire the lock, update proxy list, release
-  // the lock, and only then stop physical stream if necessary.
-  bool stop_physical_stream = false;
-  {
-    base::AutoLock lock(lock_);
-    ProxyMap::iterator it = proxies_.find(stream_proxy);
-    if (it != proxies_.end()) {
-      proxies_.erase(it);
-      stop_physical_stream = proxies_.empty();
-    }
-  }
-  if (physical_stream_.get()) {
-    if (stop_physical_stream) {
-      physical_stream_->Stop();
-      pending_bytes_ = 0;  // Just in case.
-    }
+  base::AutoLock lock(lock_);
+  ProxyMap::iterator it = proxies_.find(stream_proxy);
+  if (it != proxies_.end())
+    proxies_.erase(it);
+  if (physical_stream_.get())
     close_timer_.Reset();
-  }
 }
 
 void AudioOutputMixer::StreamVolumeSet(AudioOutputProxy* stream_proxy,
                                        double volume) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   ProxyMap::iterator it = proxies_.find(stream_proxy);
 
   // Do nothing if stream is not currently playing.
   if (it != proxies_.end()) {
@@ skipping 20 matching lines @@
   ClosePhysicalStream();
 
   // No AudioOutputProxy objects should hold a reference to us when we get
   // to this stage.
   DCHECK(HasOneRef()) << "Only the AudioManager should hold a reference";
 }
 
 void AudioOutputMixer::ClosePhysicalStream() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
-  if (proxies_.empty() && physical_stream_.get() != NULL)
+  if (proxies_.empty() && physical_stream_.get() != NULL) {
+    physical_stream_->Stop();
     physical_stream_.release()->Close();
+  }
 }
 
 // AudioSourceCallback implementation.
 uint32 AudioOutputMixer::OnMoreData(uint8* dest,
                                     uint32 max_size,
                                     AudioBuffersState buffers_state) {
   max_size = std::min(max_size,
                       static_cast<uint32>(params_.GetBytesPerBuffer()));
   // TODO(enal): consider getting rid of lock as it is in time-critical code.
   //             E.g. swap |proxies_| with local variable, and merge 2 lists
@@ skipping 80 matching lines @@
 }
 
 void AudioOutputMixer::WaitTillDataReady() {
   base::AutoLock lock(lock_);
   for (ProxyMap::iterator it = proxies_.begin(); it != proxies_.end(); ++it) {
     it->second.audio_source_callback->WaitTillDataReady();
   }
 }
 
 }  // namespace media