Revert 141476 - Do not stop audio physical stream immediately after logical one had stopped.

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);
-
-  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;
+  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);
+  }
   return true;
 }
 
 void AudioOutputMixer::StopStream(AudioOutputProxy* stream_proxy) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
-  base::AutoLock lock(lock_);
-  ProxyMap::iterator it = proxies_.find(stream_proxy);
-  if (it != proxies_.end())
-    proxies_.erase(it);
-  if (physical_stream_.get())
+  // 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.
+    }
     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) {
-    physical_stream_->Stop();
+  if (proxies_.empty() && physical_stream_.get() != NULL)
     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