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

media/audio/linux/alsa_output.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.
 //
 // THREAD SAFETY
 //
 // AlsaPcmOutputStream object is *not* thread-safe and should only be used
 // from the audio thread.  We DCHECK on this assumption whenever we can.
 //
 // SEMANTICS OF Close()
@@ skipping 188 matching lines @@
       alsa_buffer_frames_(0),
       stop_stream_(false),
       wrapper_(wrapper),
       manager_(manager),
       playback_handle_(NULL),
       frames_per_packet_(packet_size_ / bytes_per_frame_),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       state_(kCreated),
       volume_(1.0f),
       source_callback_(NULL) {
-  DCHECK_EQ(MessageLoop::current(), manager_->GetMessageLoop());
+  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 
   // Sanity check input values.
   if ((params.sample_rate > kAlsaMaxSampleRate) || (params.sample_rate <= 0)) {
     LOG(WARNING) << "Unsupported audio frequency.";
     TransitionTo(kInError);
   }
 
   if (AudioParameters::AUDIO_PCM_LINEAR != params.format &&
       AudioParameters::AUDIO_PCM_LOW_LATENCY != params.format) {
     LOG(WARNING) << "Unsupported audio format";
     TransitionTo(kInError);
   }
 
   if (pcm_format_ == SND_PCM_FORMAT_UNKNOWN) {
     LOG(WARNING) << "Unsupported bits per sample: " << params.bits_per_sample;
     TransitionTo(kInError);
   }
 }
 
 AlsaPcmOutputStream::~AlsaPcmOutputStream() {
   InternalState current_state = state();
   DCHECK(current_state == kCreated ||
          current_state == kIsClosed ||
          current_state == kInError);
   DCHECK(!playback_handle_);
 }
 
 bool AlsaPcmOutputStream::Open() {
-  DCHECK_EQ(MessageLoop::current(), manager_->GetMessageLoop());
+  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 
   if (state() == kInError)
     return false;
 
   if (!CanTransitionTo(kIsOpened)) {
     NOTREACHED() << "Invalid state: " << state();
     return false;
   }
 
   // We do not need to check if the transition was successful because
@@ skipping 37 matching lines @@
       alsa_buffer_frames_ = frames_per_packet_ * 2;
     } else {
       alsa_buffer_frames_ = buffer_size;
     }
   }
 
   return true;
 }
 
 void AlsaPcmOutputStream::Close() {
-  DCHECK_EQ(MessageLoop::current(), manager_->GetMessageLoop());
+  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 
   // Sanity check that the transition occurs correctly.  It is safe to
   // continue anyways because all operations for closing are idempotent.
   if (TransitionTo(kIsClosed) != kIsClosed) {
     NOTREACHED() << "Unable to transition Closed.";
   } else {
     // Shutdown the audio device.
     if (playback_handle_ &&
         alsa_util::CloseDevice(wrapper_, playback_handle_) < 0) {
       LOG(WARNING) << "Unable to close audio device. Leaking handle.";
     }
     playback_handle_ = NULL;
 
     // Release the buffer.
     buffer_.reset();
 
     // Signal anything that might already be scheduled to stop.
     stop_stream_ = true;  // Not necessary in production, but unit tests
                           // uses the flag to verify that stream was closed.
     weak_factory_.InvalidateWeakPtrs();
 
     // Signal to the manager that we're closed and can be removed.
     // Should be last call in the method as it deletes "this".
     manager_->ReleaseOutputStream(this);
   }
 }
 
 void AlsaPcmOutputStream::Start(AudioSourceCallback* callback) {
-  DCHECK_EQ(MessageLoop::current(), manager_->GetMessageLoop());
+  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 
   CHECK(callback);
 
   if (stop_stream_)
     return;
 
   set_source_callback(callback);
 
   // Only post the task if we can enter the playing state.
   if (TransitionTo(kIsPlaying) == kIsPlaying) {
@@ skipping 18 matching lines @@
         stop_stream_ = true;
       }
     }
 
     if (!stop_stream_)
       ScheduleNextWrite(false);
   }
 }
 
 void AlsaPcmOutputStream::Stop() {
-  DCHECK_EQ(MessageLoop::current(), manager_->GetMessageLoop());
+  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 
   // Reset the callback, so that it is not called anymore.
   set_source_callback(NULL);
 
   TransitionTo(kIsStopped);
 }
 
 void AlsaPcmOutputStream::SetVolume(double volume) {
-  DCHECK_EQ(MessageLoop::current(), manager_->GetMessageLoop());
+  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 
   volume_ = static_cast<float>(volume);
 }
 
 void AlsaPcmOutputStream::GetVolume(double* volume) {
-  DCHECK_EQ(MessageLoop::current(), manager_->GetMessageLoop());
+  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 
   *volume = volume_;
 }
 
 void AlsaPcmOutputStream::BufferPacket(bool* source_exhausted) {
-  DCHECK_EQ(MessageLoop::current(), manager_->GetMessageLoop());
+  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 
   // If stopped, simulate a 0-length packet.
   if (stop_stream_) {
     buffer_->Clear();
     *source_exhausted = true;
     return;
   }
 
   *source_exhausted = false;
 
@@ skipping 70 matching lines @@
       packet->SetDataSize(packet_size);
       // Add the packet to the buffer.
       buffer_->Append(packet);
     } else {
       *source_exhausted = true;
     }
   }
 }
 
 void AlsaPcmOutputStream::WritePacket() {
-  DCHECK_EQ(MessageLoop::current(), manager_->GetMessageLoop());
+  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 
   // If the device is in error, just eat the bytes.
   if (stop_stream_) {
     buffer_->Clear();
     return;
   }
 
   if (state() == kIsStopped)
     return;
 
@@ skipping 43 matching lines @@
     // This ensures that shorter sounds will still play.
     if (playback_handle_ &&
         (wrapper_->PcmState(playback_handle_) == SND_PCM_STATE_PREPARED) &&
         GetCurrentDelay() > 0) {
       wrapper_->PcmStart(playback_handle_);
     }
   }
 }
 
 void AlsaPcmOutputStream::WriteTask() {
-  DCHECK_EQ(MessageLoop::current(), manager_->GetMessageLoop());
+  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 
   if (stop_stream_)
     return;
 
   if (state() == kIsStopped)
     return;
 
   bool source_exhausted;
   BufferPacket(&source_exhausted);
   WritePacket();
 
   ScheduleNextWrite(source_exhausted);
 }
 
 void AlsaPcmOutputStream::ScheduleNextWrite(bool source_exhausted) {
-  DCHECK_EQ(MessageLoop::current(), manager_->GetMessageLoop());
+  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 
   if (stop_stream_)
     return;
 
   uint32 frames_avail_wanted = alsa_buffer_frames_ / 2;
   uint32 available_frames = GetAvailableFrames();
   uint32 frames_in_buffer = buffer_->forward_bytes() / bytes_per_output_frame_;
 
   // Next write is initially scheduled for the moment when half of a packet
   // has been played out.
@@ skipping 33 matching lines @@
   if (state() == kIsPlaying) {
     if (next_fill_time_ms == 0) {
       manager_->GetMessageLoop()->PostTask(FROM_HERE, base::Bind(
           &AlsaPcmOutputStream::WriteTask, weak_factory_.GetWeakPtr()));
     } else {
       // TODO(ajwong): Measure the reliability of the delay interval.  Use
       // base/metrics/histogram.h.
       manager_->GetMessageLoop()->PostDelayedTask(FROM_HERE,
           base::Bind(&AlsaPcmOutputStream::WriteTask,
                      weak_factory_.GetWeakPtr()),
-          base::TimeDelta::FromMilliseconds(next_fill_time_ms));
+          next_fill_time_ms);
     }
   }
 }
 
 uint32 AlsaPcmOutputStream::FramesToMicros(uint32 frames, uint32 sample_rate) {
   return frames * base::Time::kMicrosecondsPerSecond / sample_rate;
 }
 
 uint32 AlsaPcmOutputStream::FramesToMillis(uint32 frames, uint32 sample_rate) {
   return frames * base::Time::kMillisecondsPerSecond / sample_rate;
@@ skipping 67 matching lines @@
 
   // snd_pcm_delay() may not work in the beginning of the stream. In this case
   // return delay of data we know currently is in the ALSA's buffer.
   if (delay < 0)
     delay = alsa_buffer_frames_ - GetAvailableFrames();
 
   return delay;
 }
 
 snd_pcm_sframes_t AlsaPcmOutputStream::GetAvailableFrames() {
-  DCHECK_EQ(MessageLoop::current(), manager_->GetMessageLoop());
+  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 
   if (stop_stream_)
     return 0;
 
   // Find the number of frames queued in the sound device.
   snd_pcm_sframes_t available_frames =
       wrapper_->PcmAvailUpdate(playback_handle_);
   if (available_frames  < 0) {
     available_frames = wrapper_->PcmRecover(playback_handle_,
                                             available_frames,
@@ skipping 93 matching lines @@
       return to == kIsClosed || to == kInError;
 
     case kIsClosed:
     default:
       return false;
   }
 }
 
 AlsaPcmOutputStream::InternalState
 AlsaPcmOutputStream::TransitionTo(InternalState to) {
-  DCHECK_EQ(MessageLoop::current(), manager_->GetMessageLoop());
+  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
 
   if (!CanTransitionTo(to)) {
     NOTREACHED() << "Cannot transition from: " << state_ << " to: " << to;
     state_ = kInError;
   } else {
     state_ = to;
   }
   return state_;
 }
 
@@ skipping 13 matching lines @@
 }
 
 void AlsaPcmOutputStream::RunErrorCallback(int code) {
   if (source_callback_)
     source_callback_->OnError(this, code);
 }
 
 // Changes the AudioSourceCallback to proxy calls to.  Pass in NULL to
 // release ownership of the currently registered callback.
 void AlsaPcmOutputStream::set_source_callback(AudioSourceCallback* callback) {
-  DCHECK_EQ(MessageLoop::current(), manager_->GetMessageLoop());
+  DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
   source_callback_ = callback;
 }