Add thread safety to AudioManagerBase to protect access to the audio thread member variable.

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/synchronization/waitable_event.h"
@@ skipping 24 matching lines @@
       buffer_(0, capacity),
       pending_request_(false),
       sync_reader_(sync_reader),
       message_loop_(NULL),
       number_polling_attempts_left_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_this_(this)) {
 }
 
 AudioOutputController::~AudioOutputController() {
   DCHECK_EQ(kClosed, state_);
-  if (message_loop_ == MessageLoop::current()) {
+  DCHECK(message_loop_);
+
+  if (!message_loop_.get() || message_loop_->BelongsToCurrentThread()) {
     DoStopCloseAndClearStream(NULL);
   } else {
-    DCHECK(message_loop_);
     WaitableEvent completion(true /* manual reset */,
                              false /* initial state */);
     message_loop_->PostTask(FROM_HERE,
         base::Bind(&AudioOutputController::DoStopCloseAndClearStream,
                    base::Unretained(this),
                    &completion));
     completion.Wait();
   }
 }
 
@@ skipping 79 matching lines @@
   // If |size| is set to 0, it indicates that the audio source doesn't have
   // more data right now, and so it doesn't make sense to send additional
   // request.
   if (size) {
     buffer_.Append(data, size);
     SubmitOnMoreData_Locked();
   }
 }
 
 void AudioOutputController::DoCreate(const AudioParameters& params) {
-  DCHECK_EQ(message_loop_, MessageLoop::current());
+  DCHECK(message_loop_->BelongsToCurrentThread());
 
   // Close() can be called before DoCreate() is executed.
   if (state_ == kClosed)
     return;
   DCHECK_EQ(kEmpty, state_);
 
   DoStopCloseAndClearStream(NULL);
   stream_ = audio_manager_->MakeAudioOutputStreamProxy(params);
   if (!stream_) {
     // TODO(hclam): Define error types.
@@ skipping 19 matching lines @@
   handler_->OnCreated(this);
 
   // If in normal latency mode then start buffering.
   if (!LowLatencyMode()) {
     base::AutoLock auto_lock(lock_);
     SubmitOnMoreData_Locked();
   }
 }
 
 void AudioOutputController::DoPlay() {
-  DCHECK_EQ(message_loop_, MessageLoop::current());
+  DCHECK(message_loop_->BelongsToCurrentThread());
 
   // We can start from created or paused state.
   if (state_ != kCreated && state_ != kPaused)
     return;
 
   if (LowLatencyMode()) {
     state_ = kStarting;
 
     // Ask for first packet.
     sync_reader_->UpdatePendingBytes(0);
 
     // Cannot start stream immediately, should give renderer some time
     // to deliver data.
     number_polling_attempts_left_ = kPollNumAttempts;
     message_loop_->PostDelayedTask(
         FROM_HERE,
         base::Bind(&AudioOutputController::PollAndStartIfDataReady,
         weak_this_.GetWeakPtr()),
-        base::TimeDelta::FromMilliseconds(kPollPauseInMilliseconds));
+        kPollPauseInMilliseconds);
   } else {
     StartStream();
   }
 }
 
 void AudioOutputController::PollAndStartIfDataReady() {
-  DCHECK_EQ(message_loop_, MessageLoop::current());
+  DCHECK(message_loop_->BelongsToCurrentThread());
 
   // Being paranoid: do nothing if state unexpectedly changed.
   if ((state_ != kStarting) && (state_ != kPausedWhenStarting))
     return;
 
   bool pausing = (state_ == kPausedWhenStarting);
   // If we are ready to start the stream, start it.
   // Of course we may have to stop it immediately...
   if (--number_polling_attempts_left_ == 0 ||
       pausing ||
       sync_reader_->DataReady()) {
     StartStream();
     if (pausing) {
       DoPause();
     }
   } else {
     message_loop_->PostDelayedTask(
         FROM_HERE,
         base::Bind(&AudioOutputController::PollAndStartIfDataReady,
         weak_this_.GetWeakPtr()),
-        base::TimeDelta::FromMilliseconds(kPollPauseInMilliseconds));
+        kPollPauseInMilliseconds);
   }
 }
 
 void AudioOutputController::StartStream() {
-  DCHECK_EQ(message_loop_, MessageLoop::current());
+  DCHECK(message_loop_->BelongsToCurrentThread());
   state_ = kPlaying;
 
   // We start the AudioOutputStream lazily.
   stream_->Start(this);
 
   // Tell the event handler that we are now playing.
   handler_->OnPlaying(this);
 }
 
 void AudioOutputController::DoPause() {
-  DCHECK_EQ(message_loop_, MessageLoop::current());
+  DCHECK(message_loop_->BelongsToCurrentThread());
 
   if (stream_)
     stream_->Stop();
 
   switch (state_) {
     case kStarting:
       // We were asked to pause while starting. There is delayed task that will
       // try starting playback, and there is no way to remove that task from the
       // queue. If we stop now that task will be executed anyway.
       // Delay pausing, let delayed task to do pause after it start playback.
@@ skipping 13 matching lines @@
       }
 
       handler_->OnPaused(this);
       break;
     default:
       return;
   }
 }
 
 void AudioOutputController::DoFlush() {
-  DCHECK_EQ(message_loop_, MessageLoop::current());
+  DCHECK(message_loop_->BelongsToCurrentThread());
 
   // TODO(hclam): Actually flush the audio device.
 
   // If we are in the regular latency mode then flush the push source.
   if (!sync_reader_) {
     if (state_ != kPaused)
       return;
     base::AutoLock auto_lock(lock_);
     buffer_.Clear();
   }
 }
 
 void AudioOutputController::DoClose(const base::Closure& closed_task) {
-  DCHECK_EQ(message_loop_, MessageLoop::current());
+  DCHECK(message_loop_->BelongsToCurrentThread());
 
   if (state_ != kClosed) {
     DoStopCloseAndClearStream(NULL);
 
     if (LowLatencyMode()) {
       sync_reader_->Close();
     }
 
     state_ = kClosed;
   }
 
   closed_task.Run();
 }
 
 void AudioOutputController::DoSetVolume(double volume) {
-  DCHECK_EQ(message_loop_, MessageLoop::current());
+  DCHECK(message_loop_->BelongsToCurrentThread());
 
   // Saves the volume to a member first. We may not be able to set the volume
   // right away but when the stream is created we'll set the volume.
   volume_ = volume;
 
   switch (state_) {
     case kCreated:
     case kStarting:
     case kPausedWhenStarting:
     case kPlaying:
     case kPaused:
       stream_->SetVolume(volume_);
       break;
     default:
       return;
   }
 }
 
 void AudioOutputController::DoReportError(int code) {
-  DCHECK_EQ(message_loop_, MessageLoop::current());
+  DCHECK(message_loop_->BelongsToCurrentThread());
   if (state_ != kClosed)
     handler_->OnError(this, code);
 }
 
 uint32 AudioOutputController::OnMoreData(
     AudioOutputStream* stream, uint8* dest,
     uint32 max_size, AudioBuffersState buffers_state) {
   TRACE_EVENT0("audio", "AudioOutputController::OnMoreData");
 
   // If regular latency mode is used.
@@ skipping 62 matching lines @@
   buffers_state.pending_bytes += buffer_.forward_bytes();
 
   // If we need more data then call the event handler to ask for more data.
   // It is okay that we don't lock in this block because the parameters are
   // correct and in the worst case we are just asking more data than needed.
   base::AutoUnlock auto_unlock(lock_);
   handler_->OnMoreData(this, buffers_state);
 }
 
 void AudioOutputController::DoStopCloseAndClearStream(WaitableEvent *done) {
-  DCHECK_EQ(message_loop_, MessageLoop::current());
+  DCHECK(message_loop_->BelongsToCurrentThread());
 
   // Allow calling unconditionally and bail if we don't have a stream_ to close.
   if (stream_ != NULL) {
     stream_->Stop();
     stream_->Close();
     stream_ = NULL;
     weak_this_.InvalidateWeakPtrs();
   }
 
   // Should be last in the method, do not touch "this" from here on.
   if (done != NULL)
     done->Signal();
 }
 
 }  // namespace media