Removing DataSource from Filter hierarchy

media/filters/ffmpeg_demuxer.cc

 // Copyright (c) 2011 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/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "media/base/data_buffer.h"
-#include "media/base/filter_host.h"
 #include "media/base/limits.h"
 #include "media/base/media_switches.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/bitstream_converter.h"
 #include "media/filters/ffmpeg_demuxer.h"
 #include "media/filters/ffmpeg_glue.h"
 #include "media/filters/ffmpeg_h264_bitstream_converter.h"
 
 namespace media {
 
@@ skipping 287 matching lines @@
 
 void FFmpegDemuxer::Stop(const base::Closure& callback) {
   // Post a task to notify the streams to stop as well.
   message_loop_->PostTask(FROM_HERE,
                           base::Bind(&FFmpegDemuxer::StopTask, this, callback));
 
   // Then wakes up the thread from reading.
   SignalReadCompleted(DataSource::kReadError);
 }
 
-void FFmpegDemuxer::Seek(base::TimeDelta time, const FilterStatusCB& cb) {
+void FFmpegDemuxer::Seek(base::TimeDelta time, const PipelineStatusCB& cb) {
   message_loop_->PostTask(FROM_HERE,
                           base::Bind(&FFmpegDemuxer::SeekTask, this, time, cb));
 }
 
 void FFmpegDemuxer::SetPlaybackRate(float playback_rate) {
   DCHECK(data_source_.get());
   data_source_->SetPlaybackRate(playback_rate);
 }
 
 void FFmpegDemuxer::SetPreload(Preload preload) {
   DCHECK(data_source_.get());
   data_source_->SetPreload(preload);
 }
 
 void FFmpegDemuxer::OnAudioRendererDisabled() {
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &FFmpegDemuxer::DisableAudioStreamTask, this));
 }
 
-void FFmpegDemuxer::set_host(FilterHost* filter_host) {
-  Demuxer::set_host(filter_host);
+void FFmpegDemuxer::set_host(DemuxerHost* demuxer_host) {
+  Demuxer::set_host(demuxer_host);
   if (data_source_)
-    data_source_->set_host(filter_host);
+    data_source_->set_host(demuxer_host);
   if (max_duration_.InMicroseconds() >= 0)
     host()->SetDuration(max_duration_);
   if (read_position_ > 0)
     host()->SetCurrentReadPosition(read_position_);
   if (deferred_status_ != PIPELINE_OK)
-    host()->SetError(deferred_status_);
+    host()->OnDemuxerError(deferred_status_);
 }
 
 void FFmpegDemuxer::Initialize(DataSource* data_source,
                                const PipelineStatusCB& callback) {
   message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&FFmpegDemuxer::InitializeTask, this,
                  make_scoped_refptr(data_source),
                  callback));
 }
@@ skipping 26 matching lines @@
   // Asynchronous read from data source.
   data_source_->Read(read_position_, size, data,
                      base::Bind(&FFmpegDemuxer::OnReadCompleted, this));
 
   // TODO(hclam): The method is called on the demuxer thread and this method
   // call will block the thread. We need to implemented an additional thread to
   // let FFmpeg demuxer methods to run on.
   size_t last_read_bytes = WaitForRead();
   if (last_read_bytes == DataSource::kReadError) {
     if (host())
-      host()->SetError(PIPELINE_ERROR_READ);
+      host()->OnDemuxerError(PIPELINE_ERROR_READ);
     else
       deferred_status_ = PIPELINE_ERROR_READ;
 
     // Returns with a negative number to signal an error to FFmpeg.
     read_has_failed_ = true;
     return AVERROR(EIO);
   }
   read_position_ += last_read_bytes;
 
   if (host())
@@ skipping 165 matching lines @@
 }
 
 bool FFmpegDemuxer::IsLocalSource() {
   return local_source_;
 }
 
 bool FFmpegDemuxer::IsSeekable() {
   return !IsStreaming();
 }
 
-void FFmpegDemuxer::SeekTask(base::TimeDelta time, const FilterStatusCB& cb) {
+void FFmpegDemuxer::SeekTask(base::TimeDelta time, const PipelineStatusCB& cb) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   // TODO(scherkus): remove this by separating Seek() from Flush() from
   // Preroll() states (i.e., the implicit Seek(0) should really be a Preroll()).
   if (first_seek_hack_) {
     first_seek_hack_ = false;
 
     if (time == start_time_) {
       cb.Run(PIPELINE_OK);
       return;
@@ skipping 138 matching lines @@
   read_event_.Wait();
   return last_read_bytes_;
 }
 
 void FFmpegDemuxer::SignalReadCompleted(size_t size) {
   last_read_bytes_ = size;
   read_event_.Signal();
 }
 
 }  // namespace media