Convert some SingleThreadTaskRunner => SequencedTaskRunner.

Change-Id: I3cc29edd1f2258348b07537909f86e4c9a1b69cc
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2521168
Commit-Queue: Frank Liberato <liberato@chromium.org>
Auto-Submit: Frank Liberato <liberato@chromium.org>
Reviewed-by: Dale Curtis <dalecurtis@chromium.org>
Cr-Commit-Position: refs/heads/master@{#825104}

media/filters/decoder_stream.cc

@@ -11,7 +11,7 @@
 #include "base/feature_list.h"
 #include "base/location.h"
 #include "base/logging.h"
-#include "base/single_thread_task_runner.h"
+#include "base/sequenced_task_runner.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/cdm_context.h"
@@ -99,17 +99,17 @@ const char* GetStatusString(
 template <DemuxerStream::Type StreamType>
 DecoderStream<StreamType>::DecoderStream(
     std::unique_ptr<DecoderStreamTraits<StreamType>> traits,
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    scoped_refptr<base::SequencedTaskRunner> task_runner,
     CreateDecodersCB create_decoders_cb,
     MediaLog* media_log)
     : traits_(std::move(traits)),
-      task_runner_(task_runner),
+      task_runner_(std::move(task_runner)),
       media_log_(media_log),
       state_(STATE_UNINITIALIZED),
       stream_(nullptr),
       cdm_context_(nullptr),
       decoder_produced_a_frame_(false),
-      decoder_selector_(task_runner, std::move(create_decoders_cb), media_log),
+      decoder_selector_(task_runner_, std::move(create_decoders_cb), media_log),
       decoding_eos_(false),
       preparing_output_(false),
       pending_decode_requests_(0),
@@ -122,7 +122,7 @@ DecoderStream<StreamType>::DecoderStream(
 template <DemuxerStream::Type StreamType>
 DecoderStream<StreamType>::~DecoderStream() {
   FUNCTION_DVLOG(1);
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   if (init_cb_) {
     task_runner_->PostTask(FROM_HERE,
@@ -154,7 +154,7 @@ void DecoderStream<StreamType>::Initialize(DemuxerStream* stream,
                                            StatisticsCB statistics_cb,
                                            WaitingCB waiting_cb) {
   FUNCTION_DVLOG(1);
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
   DCHECK(!init_cb_);
   DCHECK(init_cb);
@@ -178,7 +178,7 @@ void DecoderStream<StreamType>::Initialize(DemuxerStream* stream,
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::Read(ReadCB read_cb) {
   FUNCTION_DVLOG(3);
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK(state_ != STATE_UNINITIALIZED && state_ != STATE_INITIALIZING)
       << state_;
   // No two reads in the flight at any time.
@@ -216,7 +216,7 @@ void DecoderStream<StreamType>::Read(ReadCB read_cb) {
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::Reset(base::OnceClosure closure) {
   FUNCTION_DVLOG(2);
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK_NE(state_, STATE_UNINITIALIZED);
   DCHECK(!reset_cb_);
 
@@ -265,14 +265,14 @@ void DecoderStream<StreamType>::Reset(base::OnceClosure closure) {
 
 template <DemuxerStream::Type StreamType>
 bool DecoderStream<StreamType>::CanReadWithoutStalling() const {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   return !ready_outputs_.empty() || !unprepared_outputs_.empty() ||
          (decoder_ && decoder_->CanReadWithoutStalling());
 }
 
 template <>
 bool DecoderStream<DemuxerStream::AUDIO>::CanReadWithoutStalling() const {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   return true;
 }
 
@@ -306,7 +306,7 @@ int DecoderStream<DemuxerStream::AUDIO>::GetMaxReadyOutputs() const {
 
 template <DemuxerStream::Type StreamType>
 bool DecoderStream<StreamType>::CanDecodeMore() const {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   bool buffers_left = !(fallback_buffers_.empty() && decoding_eos_);
 
@@ -319,21 +319,21 @@ bool DecoderStream<StreamType>::CanDecodeMore() const {
 
 template <DemuxerStream::Type StreamType>
 base::TimeDelta DecoderStream<StreamType>::AverageDuration() const {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   return duration_tracker_.count() ? duration_tracker_.Average()
                                    : base::TimeDelta();
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::SetPrepareCB(PrepareCB prepare_cb) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   prepare_cb_ = std::move(prepare_cb);
 }
 
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::SkipPrepareUntil(
     base::TimeDelta start_timestamp) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   skip_prepare_until_timestamp_ = start_timestamp;
 }
 
@@ -353,7 +353,7 @@ void DecoderStream<StreamType>::OnDecoderSelected(
   FUNCTION_DVLOG(1) << ": "
                     << (selected_decoder ? selected_decoder->GetDisplayName()
                                          : "No decoder selected.");
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK(state_ == STATE_INITIALIZING || state_ == STATE_REINITIALIZING_DECODER)
       << state_;
 
@@ -697,7 +697,7 @@ void DecoderStream<StreamType>::OnBufferReady(
   FUNCTION_DVLOG(3) << ": " << status << ", "
                     << (buffer ? buffer->AsHumanReadableString() : "nullptr");
 
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK(pending_demuxer_read_);
   if (!decoder_produced_a_frame_) {
     DCHECK(state_ == STATE_ERROR || state_ == STATE_REINITIALIZING_DECODER ||
@@ -834,7 +834,7 @@ void DecoderStream<StreamType>::OnBufferReady(
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::ReinitializeDecoder() {
   FUNCTION_DVLOG(2);
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK_EQ(state_, STATE_FLUSHING_DECODER);
   DCHECK_EQ(pending_decode_requests_, 0);
 
@@ -846,7 +846,7 @@ void DecoderStream<StreamType>::ReinitializeDecoder() {
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::CompleteDecoderReinitialization(bool success) {
   FUNCTION_DVLOG(2);
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK_EQ(state_, STATE_REINITIALIZING_DECODER);
 
   state_ = success ? STATE_NORMAL : STATE_ERROR;
@@ -884,7 +884,7 @@ void DecoderStream<StreamType>::CompleteDecoderReinitialization(bool success) {
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::ResetDecoder() {
   FUNCTION_DVLOG(2);
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER ||
          state_ == STATE_ERROR || state_ == STATE_END_OF_STREAM)
       << state_;
@@ -897,7 +897,7 @@ void DecoderStream<StreamType>::ResetDecoder() {
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::OnDecoderReset() {
   FUNCTION_DVLOG(2);
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER ||
          state_ == STATE_ERROR || state_ == STATE_END_OF_STREAM)
       << state_;
@@ -934,7 +934,7 @@ void DecoderStream<StreamType>::ClearOutputs() {
 template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::MaybePrepareAnotherOutput() {
   FUNCTION_DVLOG(3);
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER ||
          state_ == STATE_END_OF_STREAM ||
          state_ == STATE_REINITIALIZING_DECODER)
@@ -963,7 +963,7 @@ template <DemuxerStream::Type StreamType>
 void DecoderStream<StreamType>::OnPreparedOutputReady(
     scoped_refptr<Output> output) {
   FUNCTION_DVLOG(2);
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   // Errors and reset invalidate the WeakPtr factory for this function, so it
   // should only be called in normal and flush states.

media/filters/decoder_stream.h

@@ -28,7 +28,7 @@
 #include "media/filters/decoder_stream_traits.h"
 
 namespace base {
-class SingleThreadTaskRunner;
+class SequencedTaskRunner;
 }
 
 namespace media {
@@ -64,7 +64,7 @@ class MEDIA_EXPORT DecoderStream {
   using ReadCB = base::OnceCallback<void(ReadStatus, scoped_refptr<Output>)>;
 
   DecoderStream(std::unique_ptr<DecoderStreamTraits<StreamType>> traits,
-                const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+                scoped_refptr<base::SequencedTaskRunner> task_runner,
                 CreateDecodersCB create_decoders_cb,
                 MediaLog* media_log);
   virtual ~DecoderStream();
@@ -229,7 +229,7 @@ class MEDIA_EXPORT DecoderStream {
 
   std::unique_ptr<DecoderStreamTraits<StreamType>> traits_;
 
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
   MediaLog* media_log_;
 
   State state_;

media/filters/decrypting_media_resource.cc

@@ -22,7 +22,7 @@ DecryptingMediaResource::DecryptingMediaResource(
     MediaResource* media_resource,
     CdmContext* cdm_context,
     MediaLog* media_log,
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+    scoped_refptr<base::SequencedTaskRunner> task_runner)
     : media_resource_(media_resource),
       cdm_context_(cdm_context),
       media_log_(media_log),
@@ -33,7 +33,7 @@ DecryptingMediaResource::DecryptingMediaResource(
   DCHECK(cdm_context_->GetDecryptor());
   DCHECK(cdm_context_->GetDecryptor()->CanAlwaysDecrypt());
   DCHECK(media_log_);
-  DCHECK(task_runner->BelongsToCurrentThread());
+  DCHECK(task_runner->RunsTasksInCurrentSequence());
 }
 
 DecryptingMediaResource::~DecryptingMediaResource() = default;

media/filters/decrypting_media_resource.h

@@ -10,14 +10,10 @@
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
-#include "base/single_thread_task_runner.h"
+#include "base/sequenced_task_runner.h"
 #include "media/base/media_resource.h"
 #include "media/base/pipeline.h"
 
-namespace base {
-class SingleThreadTaskRunner;
-}  // namespace base
-
 namespace media {
 
 class CdmContext;
@@ -36,11 +32,10 @@ class MEDIA_EXPORT DecryptingMediaResource : public MediaResource {
  public:
   using InitCB = base::OnceCallback<void(bool success)>;
 
-  DecryptingMediaResource(
-      MediaResource* media_resource,
-      CdmContext* cdm_context,
-      MediaLog* media_log,
-      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+  DecryptingMediaResource(MediaResource* media_resource,
+                          CdmContext* cdm_context,
+                          MediaLog* media_log,
+                          scoped_refptr<base::SequencedTaskRunner> task_runner);
   ~DecryptingMediaResource() override;
 
   // MediaResource implementation:
@@ -58,7 +53,7 @@ class MEDIA_EXPORT DecryptingMediaResource : public MediaResource {
   MediaResource* const media_resource_;
   CdmContext* const cdm_context_;
   MediaLog* const media_log_;
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
   // Number of DecryptingDemuxerStreams that have yet to be initialized.
   int num_dds_pending_init_ = 0;

media/filters/ffmpeg_demuxer.h

@@ -34,7 +34,6 @@
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/sequenced_task_runner.h"
-#include "base/single_thread_task_runner.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decoder_buffer_queue.h"
@@ -173,7 +172,7 @@ class MEDIA_EXPORT FFmpegDemuxerStream : public DemuxerStream {
   void InitBitstreamConverter();
 
   FFmpegDemuxer* demuxer_;
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
   AVStream* stream_;
   base::TimeDelta start_time_;
   std::unique_ptr<AudioDecoderConfig> audio_config_;
@@ -210,7 +209,7 @@ class MEDIA_EXPORT FFmpegDemuxerStream : public DemuxerStream {
 
 class MEDIA_EXPORT FFmpegDemuxer : public Demuxer {
  public:
-  FFmpegDemuxer(const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+  FFmpegDemuxer(const scoped_refptr<base::SequencedTaskRunner>& task_runner,
                 DataSource* data_source,
                 const EncryptedMediaInitDataCB& encrypted_media_init_data_cb,
                 MediaTracksUpdatedCB media_tracks_updated_cb,
@@ -342,7 +341,7 @@ class MEDIA_EXPORT FFmpegDemuxer : public Demuxer {
 
   DemuxerHost* host_ = nullptr;
 
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
   // Task runner on which all blocking FFmpeg operations are executed; retrieved
   // from base::ThreadPoolInstance.