Remove calls to MessageLoop::current() in media.

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 24 matching lines @@
 #include "media/audio/alsa/alsa_output.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/free_deleter.h"
 #include "base/stl_util.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "media/audio/alsa/alsa_util.h"
 #include "media/audio/alsa/alsa_wrapper.h"
 #include "media/audio/alsa/audio_manager_alsa.h"
 #include "media/base/channel_mixer.h"
 #include "media/base/data_buffer.h"
 #include "media/base/seekable_buffer.h"
 
 namespace media {
 
@@ skipping 94 matching lines @@
       bytes_per_frame_(params.GetBytesPerFrame()),
       packet_size_(params.GetBytesPerBuffer()),
       latency_(std::max(
           base::TimeDelta::FromMicroseconds(kMinLatencyMicros),
           FramesToTimeDelta(params.frames_per_buffer() * 2, sample_rate_))),
       bytes_per_output_frame_(bytes_per_frame_),
       alsa_buffer_frames_(0),
       stop_stream_(false),
       wrapper_(wrapper),
       manager_(manager),
-      message_loop_(base::MessageLoop::current()),
+      task_runner_(base::ThreadTaskRunnerHandle::Get()),
       playback_handle_(NULL),
       frames_per_packet_(packet_size_ / bytes_per_frame_),
       state_(kCreated),
       volume_(1.0f),
       source_callback_(NULL),
       audio_bus_(AudioBus::Create(params)),
       weak_factory_(this) {
   DCHECK(manager_->GetTaskRunner()->BelongsToCurrentThread());
   DCHECK_EQ(audio_bus_->frames() * bytes_per_frame_, packet_size_);
 
@@ skipping 11 matching lines @@
 
 AlsaPcmOutputStream::~AlsaPcmOutputStream() {
   InternalState current_state = state();
   DCHECK(current_state == kCreated ||
          current_state == kIsClosed ||
          current_state == kInError);
   DCHECK(!playback_handle_);
 }
 
 bool AlsaPcmOutputStream::Open() {
-  DCHECK(IsOnAudioThread());
+  DCHECK(CalledOnValidThread());
 
   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(IsOnAudioThread());
+  DCHECK(CalledOnValidThread());
 
   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(IsOnAudioThread());
+  DCHECK(CalledOnValidThread());
 
   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(IsOnAudioThread());
+  DCHECK(CalledOnValidThread());
 
   // 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(IsOnAudioThread());
+  DCHECK(CalledOnValidThread());
 
   volume_ = static_cast<float>(volume);
 }
 
 void AlsaPcmOutputStream::GetVolume(double* volume) {
-  DCHECK(IsOnAudioThread());
+  DCHECK(CalledOnValidThread());
 
   *volume = volume_;
 }
 
 void AlsaPcmOutputStream::BufferPacket(bool* source_exhausted) {
-  DCHECK(IsOnAudioThread());
+  DCHECK(CalledOnValidThread());
 
   // 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(IsOnAudioThread());
+  DCHECK(CalledOnValidThread());
 
   // 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(IsOnAudioThread());
+  DCHECK(CalledOnValidThread());
 
   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(IsOnAudioThread());
+  DCHECK(CalledOnValidThread());
 
   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 12 matching lines @@
   } else if (!source_exhausted) {
     // The sound card has |kTargetFramesAvailable| or more frames available.
     // Invoke the next write immediately to avoid underrun.
     next_fill_time = base::TimeDelta();
   } else {
     // The sound card has frames available, but our source is exhausted, so
     // avoid busy looping by delaying a bit.
     next_fill_time = base::TimeDelta::FromMilliseconds(10);
   }
 
-  message_loop_->PostDelayedTask(FROM_HERE, base::Bind(
-      &AlsaPcmOutputStream::WriteTask, weak_factory_.GetWeakPtr()),
+  task_runner_->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&AlsaPcmOutputStream::WriteTask, weak_factory_.GetWeakPtr()),
       next_fill_time);
 }
 
 // static
 base::TimeDelta AlsaPcmOutputStream::FramesToTimeDelta(int frames,
                                                        double sample_rate) {
   return base::TimeDelta::FromMicroseconds(
       frames * base::Time::kMicrosecondsPerSecond / sample_rate);
 }
 
@@ skipping 78 matching lines @@
   }
 
   if (delay < 0) {
     delay = 0;
   }
 
   return delay;
 }
 
 snd_pcm_sframes_t AlsaPcmOutputStream::GetAvailableFrames() {
-  DCHECK(IsOnAudioThread());
+  DCHECK(CalledOnValidThread());
 
   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(IsOnAudioThread());
+  DCHECK(CalledOnValidThread());
 
   if (!CanTransitionTo(to)) {
     NOTREACHED() << "Cannot transition from: " << state_ << " to: " << to;
     state_ = kInError;
   } else {
     state_ = to;
   }
   return state_;
 }
 
 AlsaPcmOutputStream::InternalState AlsaPcmOutputStream::state() {
   return state_;
 }
 
-bool AlsaPcmOutputStream::IsOnAudioThread() const {
-  return message_loop_ && message_loop_ == base::MessageLoop::current();
-}
-
 int AlsaPcmOutputStream::RunDataCallback(AudioBus* audio_bus,
                                          uint32_t total_bytes_delay) {
   TRACE_EVENT0("audio", "AlsaPcmOutputStream::RunDataCallback");
 
   if (source_callback_)
     return source_callback_->OnMoreData(audio_bus, total_bytes_delay, 0);
 
   return 0;
 }
 
 void AlsaPcmOutputStream::RunErrorCallback(int code) {
   if (source_callback_)
     source_callback_->OnError(this);
 }
 
 // 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(IsOnAudioThread());
+  DCHECK(CalledOnValidThread());
   source_callback_ = callback;
 }
 
 }  // namespace media