Remove MessageLoop methods from Filter interface

media/filters/ffmpeg_demuxer.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 "base/callback.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
@@ skipping 221 matching lines @@
     const AVRational& time_base, int64 timestamp) {
   if (timestamp == static_cast<int64>(AV_NOPTS_VALUE))
     return kNoTimestamp;
 
   return ConvertTimestamp(time_base, timestamp);
 }
 
 //
 // FFmpegDemuxer
 //
-FFmpegDemuxer::FFmpegDemuxer()
-    : format_context_(NULL),
+FFmpegDemuxer::FFmpegDemuxer(MessageLoop* message_loop)
+    : message_loop_(message_loop),
+      format_context_(NULL),
       read_event_(false, false),
       read_has_failed_(false),
       last_read_bytes_(0),
       read_position_(0) {
+  DCHECK(message_loop_);
 }
 
 FFmpegDemuxer::~FFmpegDemuxer() {
   // In this destructor, we clean up resources held by FFmpeg. It is ugly to
   // close the codec contexts here because the corresponding codecs are opened
   // in the decoder filters. By reaching this point, all filters should have
   // stopped, so this is the only safe place to do the global clean up.
   // TODO(hclam): close the codecs in the corresponding decoders.
   if (!format_context_)
     return;
@@ skipping 14 matching lines @@
       avcodec_close(stream->codec);
     }
   }
 
   // Then finally cleanup the format context.
   av_close_input_file(format_context_);
   format_context_ = NULL;
 }
 
 void FFmpegDemuxer::PostDemuxTask() {
-  message_loop()->PostTask(FROM_HERE,
+  message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &FFmpegDemuxer::DemuxTask));
 }
 
 void FFmpegDemuxer::Stop(FilterCallback* callback) {
   // Post a task to notify the streams to stop as well.
-  message_loop()->PostTask(FROM_HERE,
+  message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &FFmpegDemuxer::StopTask, callback));
 
   // Then wakes up the thread from reading.
   SignalReadCompleted(DataSource::kReadError);
 }
 
 void FFmpegDemuxer::Seek(base::TimeDelta time, FilterCallback* callback) {
   // TODO(hclam): by returning from this method, it is assumed that the seek
   // operation is completed and filters behind the demuxer is good to issue
   // more reads, but we are posting a task here, which makes the seek operation
   // asynchronous, should change how seek works to make it fully asynchronous.
-  message_loop()->PostTask(FROM_HERE,
+  message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &FFmpegDemuxer::SeekTask, time, callback));
 }
 
 void FFmpegDemuxer::OnAudioRendererDisabled() {
-  message_loop()->PostTask(FROM_HERE,
+  message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &FFmpegDemuxer::DisableAudioStreamTask));
 }
 
 void FFmpegDemuxer::Initialize(DataSource* data_source,
                                FilterCallback* callback) {
-  message_loop()->PostTask(
+  message_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this,
                         &FFmpegDemuxer::InitializeTask,
                         make_scoped_refptr(data_source),
                         callback));
 }
 
 size_t FFmpegDemuxer::GetNumberOfStreams() {
   return streams_.size();
 }
@@ skipping 62 matching lines @@
 
   return data_source_->GetSize(size_out);
 }
 
 bool FFmpegDemuxer::IsStreaming() {
   DCHECK(data_source_);
 
   return data_source_->IsStreaming();
 }
 
+MessageLoop* FFmpegDemuxer::message_loop() {
+  return message_loop_;
+}
+
 void FFmpegDemuxer::InitializeTask(DataSource* data_source,
                                    FilterCallback* callback) {
-  DCHECK_EQ(MessageLoop::current(), message_loop());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   scoped_ptr<FilterCallback> c(callback);
 
   data_source_ = data_source;
 
   // Add ourself to Protocol list and get our unique key.
   std::string key = FFmpegGlue::GetInstance()->AddProtocol(this);
 
   // Open FFmpeg AVFormatContext.
   DCHECK(!format_context_);
   AVFormatContext* context = NULL;
@@ skipping 63 matching lines @@
     max_duration = base::TimeDelta::FromMicroseconds(
         Limits::kMaxTimeInMicroseconds);
   }
 
   // Good to go: set the duration and notify we're done initializing.
   host()->SetDuration(max_duration);
   callback->Run();
 }
 
 void FFmpegDemuxer::SeekTask(base::TimeDelta time, FilterCallback* callback) {
-  DCHECK_EQ(MessageLoop::current(), message_loop());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   scoped_ptr<FilterCallback> c(callback);
 
   // Tell streams to flush buffers due to seeking.
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     (*iter)->FlushBuffers();
   }
 
   // Always seek to a timestamp less than or equal to the desired timestamp.
   int flags = AVSEEK_FLAG_BACKWARD;
 
   // Passing -1 as our stream index lets FFmpeg pick a default stream.  FFmpeg
   // will attempt to use the lowest-index video stream, if present, followed by
   // the lowest-index audio stream.
   if (av_seek_frame(format_context_, -1, time.InMicroseconds(), flags) < 0) {
     // Use VLOG(1) instead of NOTIMPLEMENTED() to prevent the message being
     // captured from stdout and contaminates testing.
     // TODO(scherkus): Implement this properly and signal error (BUG=23447).
     VLOG(1) << "Not implemented";
   }
 
   // Notify we're finished seeking.
   callback->Run();
 }
 
 void FFmpegDemuxer::DemuxTask() {
-  DCHECK_EQ(MessageLoop::current(), message_loop());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   // Make sure we have work to do before demuxing.
   if (!StreamsHavePendingReads()) {
     return;
   }
 
   // Allocate and read an AVPacket from the media.
   scoped_ptr_malloc<AVPacket, ScopedPtrAVFreePacket> packet(new AVPacket());
   int result = av_read_frame(format_context_, packet.get());
   if (result < 0) {
@@ skipping 31 matching lines @@
   }
 
   // Create a loop by posting another task.  This allows seek and message loop
   // quit tasks to get processed.
   if (StreamsHavePendingReads()) {
     PostDemuxTask();
   }
 }
 
 void FFmpegDemuxer::StopTask(FilterCallback* callback) {
-  DCHECK_EQ(MessageLoop::current(), message_loop());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     (*iter)->Stop();
   }
   if (callback) {
     callback->Run();
     delete callback;
   }
 }
 
 void FFmpegDemuxer::DisableAudioStreamTask() {
-  DCHECK_EQ(MessageLoop::current(), message_loop());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   StreamVector::iterator iter;
   for (size_t i = 0; i < packet_streams_.size(); ++i) {
     if (!packet_streams_[i])
       continue;
 
     // If the codec type is audio, remove the reference. DemuxTask() will
     // look for such reference, and this will result in deleting the
     // audio packets after they are demuxed.
     if (packet_streams_[i]->GetAVStream()->codec->codec_type ==
         CODEC_TYPE_AUDIO) {
       packet_streams_[i] = NULL;
     }
   }
 }
 
 bool FFmpegDemuxer::StreamsHavePendingReads() {
-  DCHECK_EQ(MessageLoop::current(), message_loop());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     if ((*iter)->HasPendingReads()) {
       return true;
     }
   }
   return false;
 }
 
 void FFmpegDemuxer::StreamHasEnded() {
-  DCHECK_EQ(MessageLoop::current(), message_loop());
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     AVPacket* packet = new AVPacket();
     memset(packet, 0, sizeof(*packet));
     (*iter)->EnqueuePacket(packet);
   }
 }
 
 void FFmpegDemuxer::OnReadCompleted(size_t size) {
   SignalReadCompleted(size);
 }
 
 size_t FFmpegDemuxer::WaitForRead() {
   read_event_.Wait();
   return last_read_bytes_;
 }
 
 void FFmpegDemuxer::SignalReadCompleted(size_t size) {
   last_read_bytes_ = size;
   read_event_.Signal();
 }
 
 }  // namespace media