Remove MessageLoop methods from Filter interface

media/filters/ffmpeg_video_decoder.cc

 // Copyright (c) 2010 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 <deque>
 
 #include "base/task.h"
 #include "media/base/callback.h"
 #include "media/base/filters.h"
 #include "media/base/filter_host.h"
 #include "media/base/limits.h"
 #include "media/base/media_format.h"
 #include "media/base/video_frame.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/ffmpeg/ffmpeg_util.h"
 #include "media/filters/ffmpeg_interfaces.h"
 #include "media/video/ffmpeg_video_decode_engine.h"
 #include "media/video/video_decode_context.h"
 
 namespace media {
 
-FFmpegVideoDecoder::FFmpegVideoDecoder(VideoDecodeContext* decode_context)
-    : width_(0),
+FFmpegVideoDecoder::FFmpegVideoDecoder(MessageLoop* message_loop,
+                                       VideoDecodeContext* decode_context)
+    : message_loop_(message_loop),
+      width_(0),
       height_(0),
       time_base_(new AVRational()),
       state_(kUnInitialized),
       decode_engine_(new FFmpegVideoDecodeEngine()),
       decode_context_(decode_context) {
   memset(&info_, 0, sizeof(info_));
 }
 
 FFmpegVideoDecoder::~FFmpegVideoDecoder() {
 }
 
 void FFmpegVideoDecoder::Initialize(DemuxerStream* demuxer_stream,
                                     FilterCallback* callback) {
-  if (MessageLoop::current() != message_loop()) {
-    message_loop()->PostTask(
+  if (MessageLoop::current() != message_loop_) {
+    message_loop_->PostTask(
         FROM_HERE,
         NewRunnableMethod(this,
                           &FFmpegVideoDecoder::Initialize,
                           make_scoped_refptr(demuxer_stream),
                           callback));
     return;
   }
 
-  DCHECK_EQ(MessageLoop::current(), message_loop());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(!demuxer_stream_);
   DCHECK(!initialize_callback_.get());
 
   demuxer_stream_ = demuxer_stream;
   initialize_callback_.reset(callback);
 
   // Get the AVStream by querying for the provider interface.
   AVStreamProvider* av_stream_provider;
   if (!demuxer_stream->QueryInterface(&av_stream_provider)) {
     VideoCodecInfo info = {0};
@@ skipping 31 matching lines @@
       config.codec = kCodecMPEG4; break;
     case CODEC_ID_VP8:
       config.codec = kCodecVP8; break;
     default:
       NOTREACHED();
   }
   config.opaque_context = av_stream;
   config.width = width_;
   config.height = height_;
   state_ = kInitializing;
-  decode_engine_->Initialize(message_loop(), this, NULL, config);
+  decode_engine_->Initialize(message_loop_, this, NULL, config);
 }
 
 void FFmpegVideoDecoder::OnInitializeComplete(const VideoCodecInfo& info) {
-  DCHECK_EQ(MessageLoop::current(), message_loop());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(initialize_callback_.get());
 
   info_ = info;  // Save a copy.
 
   if (info.success) {
     media_format_.SetAsString(MediaFormat::kMimeType,
                               mime_type::kUncompressedVideo);
     media_format_.SetAsInteger(MediaFormat::kWidth, width_);
     media_format_.SetAsInteger(MediaFormat::kHeight, height_);
     media_format_.SetAsInteger(
         MediaFormat::kSurfaceType,
         static_cast<int>(info.stream_info.surface_type));
     media_format_.SetAsInteger(
         MediaFormat::kSurfaceFormat,
         static_cast<int>(info.stream_info.surface_format));
     state_ = kNormal;
   } else {
     host()->SetError(PIPELINE_ERROR_DECODE);
   }
 
   initialize_callback_->Run();
   initialize_callback_.reset();
 }
 
 void FFmpegVideoDecoder::Stop(FilterCallback* callback) {
-  if (MessageLoop::current() != message_loop()) {
-    message_loop()->PostTask(FROM_HERE,
+  if (MessageLoop::current() != message_loop_) {
+    message_loop_->PostTask(FROM_HERE,
                              NewRunnableMethod(this,
                                                &FFmpegVideoDecoder::Stop,
                                                callback));
     return;
   }
 
-  DCHECK_EQ(MessageLoop::current(), message_loop());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(!uninitialize_callback_.get());
 
   uninitialize_callback_.reset(callback);
   if (state_ != kUnInitialized)
     decode_engine_->Uninitialize();
   else
     OnUninitializeComplete();
 }
 
 void FFmpegVideoDecoder::OnUninitializeComplete() {
-  DCHECK_EQ(MessageLoop::current(), message_loop());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(uninitialize_callback_.get());
 
   AutoCallbackRunner done_runner(uninitialize_callback_.release());
   state_ = kStopped;
 
   // TODO(jiesun): Destroy the decoder context.
 }
 
 void FFmpegVideoDecoder::Pause(FilterCallback* callback) {
-  if (MessageLoop::current() != message_loop()) {
-    message_loop()->PostTask(FROM_HERE,
+  if (MessageLoop::current() != message_loop_) {
+    message_loop_->PostTask(FROM_HERE,
                              NewRunnableMethod(this,
                                                &FFmpegVideoDecoder::Pause,
                                                callback));
     return;
   }
 
   AutoCallbackRunner done_runner(callback);
   state_ = kPausing;
 }
 
 void FFmpegVideoDecoder::Flush(FilterCallback* callback) {
-  if (MessageLoop::current() != message_loop()) {
-    message_loop()->PostTask(FROM_HERE,
+  if (MessageLoop::current() != message_loop_) {
+    message_loop_->PostTask(FROM_HERE,
                              NewRunnableMethod(this,
                                                &FFmpegVideoDecoder::Flush,
                                                callback));
     return;
   }
 
-  DCHECK_EQ(MessageLoop::current(), message_loop());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(!flush_callback_.get());
 
   state_ = kFlushing;
 
   FlushBuffers();
 
   flush_callback_.reset(callback);
 
   decode_engine_->Flush();
 }
 
 void FFmpegVideoDecoder::OnFlushComplete() {
-  DCHECK_EQ(MessageLoop::current(), message_loop());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(flush_callback_.get());
 
   AutoCallbackRunner done_runner(flush_callback_.release());
 
   // Everything in the presentation time queue is invalid, clear the queue.
   while (!pts_heap_.IsEmpty())
     pts_heap_.Pop();
 
   // Mark flush operation had been done.
   state_ = kNormal;
 }
 
 void FFmpegVideoDecoder::Seek(base::TimeDelta time,
                               FilterCallback* callback) {
-  if (MessageLoop::current() != message_loop()) {
-     message_loop()->PostTask(FROM_HERE,
+  if (MessageLoop::current() != message_loop_) {
+     message_loop_->PostTask(FROM_HERE,
                               NewRunnableMethod(this,
                                                 &FFmpegVideoDecoder::Seek,
                                                 time,
                                                 callback));
      return;
   }
 
-  DCHECK_EQ(MessageLoop::current(), message_loop());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(!seek_callback_.get());
 
   seek_callback_.reset(callback);
   decode_engine_->Seek();
 }
 
 void FFmpegVideoDecoder::OnSeekComplete() {
-  DCHECK_EQ(MessageLoop::current(), message_loop());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(seek_callback_.get());
 
   AutoCallbackRunner done_runner(seek_callback_.release());
 }
 
 void FFmpegVideoDecoder::OnError() {
   NOTIMPLEMENTED();
 }
 
 void FFmpegVideoDecoder::OnFormatChange(VideoStreamInfo stream_info) {
   NOTIMPLEMENTED();
 }
 
 void FFmpegVideoDecoder::OnReadComplete(Buffer* buffer_in) {
   scoped_refptr<Buffer> buffer(buffer_in);
-  message_loop()->PostTask(
+  message_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this,
                         &FFmpegVideoDecoder::OnReadCompleteTask,
                         buffer));
 }
 
 void FFmpegVideoDecoder::OnReadCompleteTask(scoped_refptr<Buffer> buffer) {
-  DCHECK_EQ(MessageLoop::current(), message_loop());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK_NE(state_, kStopped);  // because of Flush() before Stop().
 
   // During decode, because reads are issued asynchronously, it is possible to
   // receive multiple end of stream buffers since each read is acked. When the
   // first end of stream buffer is read, FFmpeg may still have frames queued
   // up in the decoder so we need to go through the decode loop until it stops
   // giving sensible data.  After that, the decoder should output empty
   // frames.  There are three states the decoder can be in:
   //
   //   kNormal: This is the starting state. Buffers are decoded. Decode errors
@@ skipping 33 matching lines @@
   // Otherwise, attempt to decode a single frame.
   decode_engine_->ConsumeVideoSample(buffer);
 }
 
 const MediaFormat& FFmpegVideoDecoder::media_format() {
   return media_format_;
 }
 
 void FFmpegVideoDecoder::ProduceVideoFrame(
     scoped_refptr<VideoFrame> video_frame) {
-  if (MessageLoop::current() != message_loop()) {
-    message_loop()->PostTask(
+  if (MessageLoop::current() != message_loop_) {
+    message_loop_->PostTask(
         FROM_HERE,
         NewRunnableMethod(this,
                           &FFmpegVideoDecoder::ProduceVideoFrame, video_frame));
     return;
   }
 
-  DCHECK_EQ(MessageLoop::current(), message_loop());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   // Synchronized flushing before stop should prevent this.
   DCHECK_NE(state_, kStopped);
 
   // If the decoding is finished, we just always return empty frames.
   if (state_ == kDecodeFinished) {
     // Signal VideoRenderer the end of the stream event.
     scoped_refptr<VideoFrame> empty_frame;
     VideoFrame::CreateEmptyFrame(&empty_frame);
     VideoFrameReady(empty_frame);
 
     // Fall through, because we still need to keep record of this frame.
   }
 
   // Notify decode engine the available of new frame.
   decode_engine_->ProduceVideoFrame(video_frame);
 }
 
 void FFmpegVideoDecoder::ConsumeVideoFrame(
     scoped_refptr<VideoFrame> video_frame) {
-  DCHECK_EQ(MessageLoop::current(), message_loop());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK_NE(state_, kStopped);
 
   if (video_frame.get()) {
     if (kPausing == state_ || kFlushing == state_) {
       frame_queue_flushed_.push_back(video_frame);
       if (kFlushing == state_)
         FlushBuffers();
       return;
     }
 
@@ skipping 14 matching lines @@
       // Signal VideoRenderer the end of the stream event.
       scoped_refptr<VideoFrame> video_frame;
       VideoFrame::CreateEmptyFrame(&video_frame);
       VideoFrameReady(video_frame);
     }
   }
 }
 
 void FFmpegVideoDecoder::ProduceVideoSample(
     scoped_refptr<Buffer> buffer) {
-  DCHECK_EQ(MessageLoop::current(), message_loop());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK_NE(state_, kStopped);
 
   demuxer_stream_->Read(
       NewCallback(this, &FFmpegVideoDecoder::OnReadComplete));
 }
 
 FFmpegVideoDecoder::TimeTuple FFmpegVideoDecoder::FindPtsAndDuration(
     const AVRational& time_base,
     PtsHeap* pts_heap,
     const TimeTuple& last_pts,
@@ skipping 61 matching lines @@
       VideoFrameReady(video_frame);
   }
 }
 
 void FFmpegVideoDecoder::SetVideoDecodeEngineForTest(
     VideoDecodeEngine* engine) {
   decode_engine_.reset(engine);
 }
 
 }  // namespace media