Replace deprecated base::NonThreadSafe in media/audio in favor of SequenceChecker.

media/audio/alsa/alsa_output.cc

 // Copyright 2013 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 168 matching lines @@
     TransitionTo(kInError);
   }
 
   if (pcm_format_ == SND_PCM_FORMAT_UNKNOWN) {
     LOG(WARNING) << "Unsupported bits per sample: " << params.bits_per_sample();
     TransitionTo(kInError);
   }
 }
 
 AlsaPcmOutputStream::~AlsaPcmOutputStream() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   InternalState current_state = state();
   DCHECK(current_state == kCreated ||
          current_state == kIsClosed ||
          current_state == kInError);
   DCHECK(!playback_handle_);
 }
 
 bool AlsaPcmOutputStream::Open() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   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 @@
     // Buffer size is at least twice of packet size.
     alsa_buffer_frames_ = frames_per_packet_ * 2;
   } else {
     alsa_buffer_frames_ = buffer_size;
   }
 
   return true;
 }
 
 void AlsaPcmOutputStream::Close() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (state() != kIsClosed)
     TransitionTo(kIsClosed);
 
   // Shutdown the audio device.
   if (playback_handle_) {
     if (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(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   CHECK(callback);
 
   if (stop_stream_)
     return;
 
   // Only post the task if we can enter the playing state.
   if (TransitionTo(kIsPlaying) != kIsPlaying)
     return;
 
@@ skipping 28 matching lines @@
   memset(silent_packet->writable_data(), 0, silent_packet->data_size());
   buffer_->Append(silent_packet);
   WritePacket();
 
   // Start the callback chain.
   set_source_callback(callback);
   WriteTask();
 }
 
 void AlsaPcmOutputStream::Stop() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // Reset the callback, so that it is not called anymore.
   set_source_callback(NULL);
   weak_factory_.InvalidateWeakPtrs();
 
   TransitionTo(kIsStopped);
 }
 
 void AlsaPcmOutputStream::SetVolume(double volume) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   volume_ = static_cast<float>(volume);
 }
 
 void AlsaPcmOutputStream::GetVolume(double* volume) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   *volume = volume_;
 }
 
 void AlsaPcmOutputStream::SetTickClockForTesting(
     std::unique_ptr<base::TickClock> tick_clock) {
   DCHECK(tick_clock);
   tick_clock_ = std::move(tick_clock);
 }
 
 void AlsaPcmOutputStream::BufferPacket(bool* source_exhausted) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // If stopped, simulate a 0-length packet.
   if (stop_stream_) {
     buffer_->Clear();
     *source_exhausted = true;
     return;
   }
 
   *source_exhausted = false;
 
@@ skipping 53 matching lines @@
       packet->set_data_size(packet_size);
       // Add the packet to the buffer.
       buffer_->Append(packet);
     } else {
       *source_exhausted = true;
     }
   }
 }
 
 void AlsaPcmOutputStream::WritePacket() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // If the device is in error, just eat the bytes.
   if (stop_stream_) {
     buffer_->Clear();
     return;
   }
 
   if (state() != kIsPlaying)
     return;
 
@@ skipping 38 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(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   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(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (stop_stream_ || state() != kIsPlaying)
     return;
 
   const uint32_t kTargetFramesAvailable = alsa_buffer_frames_ / 2;
   uint32_t available_frames = GetAvailableFrames();
 
   base::TimeDelta next_fill_time;
   if (buffer_->forward_bytes() && available_frames) {
     // If we've got data available and ALSA has room, deliver it immediately.
@@ skipping 106 matching lines @@
   }
 
   if (delay < 0) {
     delay = 0;
   }
 
   return delay;
 }
 
 snd_pcm_sframes_t AlsaPcmOutputStream::GetAvailableFrames() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   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 112 matching lines @@
       return to == kIsClosed || to == kInError;
 
     case kIsClosed:
     default:
       return false;
   }
 }
 
 AlsaPcmOutputStream::InternalState
 AlsaPcmOutputStream::TransitionTo(InternalState to) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   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();
 }
 
 // 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(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   source_callback_ = callback;
 }
 
 }  // namespace media