Made MediaFilter::host_ and MediaFilter::message_loop_ private.

media/filters/ffmpeg_demuxer.cc

 // Copyright (c) 2009 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/scoped_ptr.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "media/base/filter_host.h"
 #include "media/filters/ffmpeg_common.h"
@@ skipping 138 matching lines @@
   STLDeleteElements(&read_queue_);
   stopped_ = true;
 }
 
 const MediaFormat& FFmpegDemuxerStream::media_format() {
   return media_format_;
 }
 
 void FFmpegDemuxerStream::Read(Callback1<Buffer*>::Type* read_callback) {
   DCHECK(read_callback);
-  demuxer_->message_loop_->PostTask(FROM_HERE,
+  demuxer_->message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(this, &FFmpegDemuxerStream::ReadTask, read_callback));
 }
 
 void FFmpegDemuxerStream::ReadTask(Callback1<Buffer*>::Type* read_callback) {
   DCHECK_EQ(PlatformThread::CurrentId(), demuxer_->thread_id_);
 
   // Don't accept any additional reads if we've been told to stop.
   //
   // TODO(scherkus): it would be cleaner if we replied with an error message.
   if (stopped_) {
@@ skipping 75 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() {
   // 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));
 }
 
 void FFmpegDemuxer::Seek(base::TimeDelta time) {
   // 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));
 }
 
 bool FFmpegDemuxer::Initialize(DataSource* data_source) {
-  message_loop_->PostTask(FROM_HERE,
+  message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(this, &FFmpegDemuxer::InititalizeTask, data_source));
   return true;
 }
 
 size_t FFmpegDemuxer::GetNumberOfStreams() {
   return streams_.size();
 }
 
 scoped_refptr<DemuxerStream> FFmpegDemuxer::GetStream(int stream) {
   DCHECK(stream >= 0);
@@ skipping 20 matching lines @@
 
   // Open FFmpeg AVFormatContext.
   DCHECK(!format_context_);
   AVFormatContext* context = NULL;
   int result = av_open_input_file(&context, key.c_str(), NULL, 0, NULL);
 
   // Remove our data source.
   FFmpegGlue::get()->RemoveDataSource(data_source);
 
   if (result < 0) {
-    host_->Error(DEMUXER_ERROR_COULD_NOT_OPEN);
+    host()->Error(DEMUXER_ERROR_COULD_NOT_OPEN);
     return;
   }
 
   DCHECK(context);
   format_context_ = context;
 
   // Serialize calls to av_find_stream_info().
   {
     AutoLock auto_lock(FFmpegLock::get()->lock());
 
     // Fully initialize AVFormatContext by parsing the stream a little.
     result = av_find_stream_info(format_context_);
     if (result < 0) {
-      host_->Error(DEMUXER_ERROR_COULD_NOT_PARSE);
+      host()->Error(DEMUXER_ERROR_COULD_NOT_PARSE);
       return;
     }
   }
 
   // Create demuxer streams for all supported streams.
   base::TimeDelta max_duration;
   for (size_t i = 0; i < format_context_->nb_streams; ++i) {
     CodecType codec_type = format_context_->streams[i]->codec->codec_type;
     if (codec_type == CODEC_TYPE_AUDIO || codec_type == CODEC_TYPE_VIDEO) {
       AVStream* stream = format_context_->streams[i];
       FFmpegDemuxerStream* demuxer_stream
           = new FFmpegDemuxerStream(this, stream);
       DCHECK(demuxer_stream);
       streams_.push_back(demuxer_stream);
       packet_streams_.push_back(demuxer_stream);
       max_duration = std::max(max_duration, demuxer_stream->duration());
     } else {
       packet_streams_.push_back(NULL);
     }
   }
   if (streams_.empty()) {
-    host_->Error(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
+    host()->Error(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
     return;
   }
 
   // Good to go: set the duration and notify we're done initializing.
-  host_->SetDuration(max_duration);
-  host_->InitializationComplete();
+  host()->SetDuration(max_duration);
+  host()->InitializationComplete();
 }
 
 void FFmpegDemuxer::SeekTask(base::TimeDelta time) {
   DCHECK_EQ(PlatformThread::CurrentId(), thread_id_);
 
   // Tell streams to flush buffers due to seeking.
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     (*iter)->FlushBuffers();
   }
@@ skipping 91 matching lines @@
   DCHECK_EQ(PlatformThread::CurrentId(), thread_id_);
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     AVPacket* packet = new AVPacket();
     memset(packet, 0, sizeof(*packet));
     (*iter)->EnqueuePacket(packet);
   }
 }
 
 }  // namespace media