Add a lock around getting and setting of source_ to avoid possible compiler reorderings.

media/audio/mac/audio_output_mac.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 "media/audio/mac/audio_output_mac.h"
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 73 matching lines @@
   silence_bytes_ = format_.mBytesPerFrame * params.sample_rate * 6 / 1000;
 }
 
 PCMQueueOutAudioOutputStream::~PCMQueueOutAudioOutputStream() {
 }
 
 void PCMQueueOutAudioOutputStream::HandleError(OSStatus err) {
   // source_ can be set to NULL from another thread. We need to cache its
   // pointer while we operate here. Note that does not mean that the source
   // has been destroyed.
-  AudioSourceCallback* source = source_;
+  AudioSourceCallback* source = GetSource();
   if (source)
     source->OnError(this, static_cast<int>(err));
   NOTREACHED() << "error code " << err;
 }
 
 bool PCMQueueOutAudioOutputStream::Open() {
   // Get the default device id.
   AudioObjectID device_id = 0;
   AudioObjectPropertyAddress property_address = {
       kAudioHardwarePropertyDefaultOutputDevice,
@@ skipping 45 matching lines @@
     format_.mChannelsPerFrame = num_core_channels_;
     format_.mBytesPerFrame = (format_.mBitsPerChannel >> 3) *
         format_.mChannelsPerFrame;
     format_.mBytesPerPacket = format_.mBytesPerFrame * format_.mFramesPerPacket;
   } else {
     should_down_mix_ = false;
   }
   // Create the actual queue object and let the OS use its own thread to
   // run its CFRunLoop.
   err = AudioQueueNewOutput(&format_, RenderCallback, this, NULL,
-                                     kCFRunLoopCommonModes, 0, &audio_queue_);
+                            kCFRunLoopCommonModes, 0, &audio_queue_);
   if (err != noErr) {
     HandleError(err);
     return false;
   }
   // Allocate the hardware-managed buffers.
   for (uint32 ix = 0; ix != kNumBuffers; ++ix) {
     err = AudioQueueAllocateBuffer(audio_queue_, packet_size_, &buffer_[ix]);
     if (err != noErr) {
       HandleError(err);
       return false;
@@ skipping 136 matching lines @@
       HandleError(err);
   }
   // Inform the audio manager that we have been closed. This can cause our
   // destruction.
   manager_->ReleaseOutputStream(this);
 }
 
 void PCMQueueOutAudioOutputStream::Stop() {
   // We request a synchronous stop, so the next call can take some time. In
   // the windows implementation we block here as well.
-  source_ = NULL;
+  SetSource(NULL);
+
   // We set the source to null to signal to the data queueing thread it can stop
   // queueing data, however at most one callback might still be in flight which
   // could attempt to enqueue right after the next call. Rather that trying to
   // use a lock we rely on the internal Mac queue lock so the enqueue might
   // succeed or might fail but it won't crash or leave the queue itself in an
   // inconsistent state.
   OSStatus err = AudioQueueStop(audio_queue_, true);
   if (err != noErr)
     HandleError(err);
 }
@@ skipping 43 matching lines @@
       core_channel_orderings_[input_channel] == kEmptyChannel &&
       kChannelOrderings[source_layout_][input_channel] > kEmptyChannel &&
       kChannelOrderings[source_layout_][output_channel] == kEmptyChannel) {
     channel_remap_[core_channel_orderings_[output_channel]] =
         kChannelOrderings[source_layout_][input_channel];
     return true;
   }
   return false;
 }
 
-// Note to future hackers of this function: Do not add locks here because we
-// call out to third party source that might do crazy things including adquire
-// external locks or somehow re-enter here because its legal for them to call
-// some audio functions.
+// Note to future hackers of this function: Do not add locks to this function
+// that are held through any calls made back into AudioQueue APIs, or other
+// OS audio functions.  This is because the OS dispatch may grab external
+// locks, or possibly re-enter this function which can lead to a deadlock.
 void PCMQueueOutAudioOutputStream::RenderCallback(void* p_this,
                                                   AudioQueueRef queue,
                                                   AudioQueueBufferRef buffer) {
   TRACE_EVENT0("audio", "PCMQueueOutAudioOutputStream::RenderCallback");
 
   PCMQueueOutAudioOutputStream* audio_stream =
       static_cast<PCMQueueOutAudioOutputStream*>(p_this);
   // Call the audio source to fill the free buffer with data. Not having a
   // source means that the queue has been closed. This is not an error.
-  AudioSourceCallback* source = audio_stream->source_;
+  AudioSourceCallback* source = audio_stream->GetSource();
   if (!source)
     return;
 
   // Adjust the number of pending bytes by subtracting the amount played.
   if (!static_cast<AudioQueueUserData*>(buffer->mUserData)->empty_buffer)
     audio_stream->pending_bytes_ -= buffer->mAudioDataByteSize;
   uint32 capacity = buffer->mAudioDataBytesCapacity;
   // TODO(sergeyu): Specify correct hardware delay for AudioBuffersState.
   uint32 filled = source->OnMoreData(
       audio_stream, reinterpret_cast<uint8*>(buffer->mAudioData), capacity,
@@ skipping 55 matching lines @@
   if (!static_cast<AudioQueueUserData*>(buffer->mUserData)->empty_buffer)
     audio_stream->pending_bytes_ += filled;
   if (NULL == queue)
     return;
   // Queue the audio data to the audio driver.
   OSStatus err = AudioQueueEnqueueBuffer(queue, buffer, 0, NULL);
   if (err != noErr) {
     if (err == kAudioQueueErr_EnqueueDuringReset) {
       // This is the error you get if you try to enqueue a buffer and the
       // queue has been closed. Not really a problem if indeed the queue
-      // has been closed.
-      if (!audio_stream->source_)
+      // has been closed.  We recheck the value of source now to see if it has
+      // indeed been closed.
+      if (!audio_stream->GetSource())
         return;
     }
     audio_stream->HandleError(err);
   }
 }
 
 void PCMQueueOutAudioOutputStream::Start(AudioSourceCallback* callback) {
   DCHECK(callback);
   OSStatus err = noErr;
-  source_ = callback;
+  SetSource(callback);
   pending_bytes_ = 0;
   // Ask the source to pre-fill all our buffers before playing.
   for (uint32 ix = 0; ix != kNumBuffers; ++ix) {
     buffer_[ix]->mAudioDataByteSize = 0;
     RenderCallback(this, NULL, buffer_[ix]);
   }
 
   // Queue the buffers to the audio driver, sounds starts now.
   for (uint32 ix = 0; ix != kNumBuffers; ++ix) {
     err = AudioQueueEnqueueBuffer(audio_queue_, buffer_[ix], 0, NULL);
     if (err != noErr) {
       HandleError(err);
       return;
     }
   }
   err  = AudioQueueStart(audio_queue_, NULL);
   if (err != noErr) {
     HandleError(err);
     return;
   }
 }
+
+void PCMQueueOutAudioOutputStream::SetSource(AudioSourceCallback* source) {
+  base::AutoLock lock(source_lock_);
+  source_ = source;
+}
+
+AudioOutputStream::AudioSourceCallback*
+PCMQueueOutAudioOutputStream::GetSource() {
+  base::AutoLock lock(source_lock_);
+  return source_;
+}