media::FFmpegVideoDecoder: remove ctor param |task_runner| and use a ThreadChecker instead.

media/filters/ffmpeg_video_decoder.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/filters/ffmpeg_video_decoder.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 54 matching lines @@
   scoped_refptr<VideoFrame> video_frame;
   video_frame.swap(reinterpret_cast<VideoFrame**>(&opaque));
 }
 
 // static
 bool FFmpegVideoDecoder::IsCodecSupported(VideoCodec codec) {
   FFmpegGlue::InitializeFFmpeg();
   return avcodec_find_decoder(VideoCodecToCodecID(codec)) != nullptr;
 }
 
-FFmpegVideoDecoder::FFmpegVideoDecoder(
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
-    : task_runner_(task_runner), state_(kUninitialized),
-      decode_nalus_(false) {}
+FFmpegVideoDecoder::FFmpegVideoDecoder()
+    : state_(kUninitialized), decode_nalus_(false) {
+  thread_checker_.DetachFromThread();
+}
 
 int FFmpegVideoDecoder::GetVideoBuffer(struct AVCodecContext* codec_context,
                                        AVFrame* frame,
                                        int flags) {
   // Don't use |codec_context_| here! With threaded decoding,
   // it will contain unsynchronized width/height/pix_fmt values,
   // whereas |codec_context| contains the current threads's
   // updated width/height/pix_fmt, which can change for adaptive
   // content.
   const VideoPixelFormat format =
@@ skipping 72 matching lines @@
 
 std::string FFmpegVideoDecoder::GetDisplayName() const {
   return "FFmpegVideoDecoder";
 }
 
 void FFmpegVideoDecoder::Initialize(const VideoDecoderConfig& config,
                                     bool low_delay,
                                     const SetCdmReadyCB& /* set_cdm_ready_cb */,
                                     const InitCB& init_cb,
                                     const OutputCB& output_cb) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(config.IsValidConfig());
   DCHECK(!output_cb.is_null());
 
   InitCB bound_init_cb = BindToCurrentLoop(init_cb);
 
   if (config.is_encrypted()) {
     bound_init_cb.Run(false);
     return;
   }
 
   FFmpegGlue::InitializeFFmpeg();
   config_ = config;
 
   // TODO(xhwang): Only set |config_| after we successfully configure the
   // decoder.
   if (!ConfigureDecoder(low_delay)) {
     bound_init_cb.Run(false);
     return;
   }
 
   output_cb_ = BindToCurrentLoop(output_cb);
 
   // Success!
   state_ = kNormal;
   bound_init_cb.Run(true);
 }
 
 void FFmpegVideoDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
                                 const DecodeCB& decode_cb) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(buffer.get());
   DCHECK(!decode_cb.is_null());
   CHECK_NE(state_, kUninitialized);
 
   DecodeCB decode_cb_bound = BindToCurrentLoop(decode_cb);
 
   if (state_ == kError) {
     decode_cb_bound.Run(kDecodeError);
     return;
   }
@@ skipping 39 matching lines @@
 
   if (buffer->end_of_stream())
     state_ = kDecodeFinished;
 
   // VideoDecoderShim expects that |decode_cb| is called only after
   // |output_cb_|.
   decode_cb_bound.Run(kOk);
 }
 
 void FFmpegVideoDecoder::Reset(const base::Closure& closure) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   avcodec_flush_buffers(codec_context_.get());
   state_ = kNormal;
-  task_runner_->PostTask(FROM_HERE, closure);
+  // PostTask() to avoid calling |closure| inmediately.
+  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, closure);
 }
 
 FFmpegVideoDecoder::~FFmpegVideoDecoder() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   if (state_ != kUninitialized)
     ReleaseFFmpegResources();
 }
 
 bool FFmpegVideoDecoder::FFmpegDecode(
     const scoped_refptr<DecoderBuffer>& buffer,
     bool* has_produced_frame) {
   DCHECK(!*has_produced_frame);
 
@@ skipping 88 matching lines @@
   if (!codec || avcodec_open2(codec_context_.get(), codec, NULL) < 0) {
     ReleaseFFmpegResources();
     return false;
   }
 
   av_frame_.reset(av_frame_alloc());
   return true;
 }
 
 }  // namespace media