Move Demuxer::set_host() to Initialize().

media/filters/ffmpeg_demuxer.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 "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"
@@ skipping 262 matching lines @@
   return ConvertFromTimeBase(time_base, timestamp);
 }
 
 //
 // FFmpegDemuxer
 //
 FFmpegDemuxer::FFmpegDemuxer(
     MessageLoop* message_loop,
     const scoped_refptr<DataSource>& data_source,
     bool local_source)
-    : message_loop_(message_loop),
+    : host_(NULL),
+      message_loop_(message_loop),
       local_source_(local_source),
       format_context_(NULL),
       data_source_(data_source),
       read_event_(false, false),
       read_has_failed_(false),
       last_read_bytes_(0),
       read_position_(0),
       bitrate_(0),
       first_seek_hack_(true),
       start_time_(kNoTimestamp()),
@@ skipping 37 matching lines @@
 void FFmpegDemuxer::SetPlaybackRate(float playback_rate) {
   DCHECK(data_source_.get());
   data_source_->SetPlaybackRate(playback_rate);
 }
 
 void FFmpegDemuxer::OnAudioRendererDisabled() {
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &FFmpegDemuxer::DisableAudioStreamTask, this));
 }
 
-void FFmpegDemuxer::set_host(DemuxerHost* demuxer_host) {
-  Demuxer::set_host(demuxer_host);
-  data_source_->set_host(demuxer_host);
-}
-
-void FFmpegDemuxer::Initialize(const PipelineStatusCB& status_cb) {
+void FFmpegDemuxer::Initialize(DemuxerHost* host,
+                               const PipelineStatusCB& status_cb) {
   message_loop_->PostTask(FROM_HERE, base::Bind(
-      &FFmpegDemuxer::InitializeTask, this, status_cb));
+      &FFmpegDemuxer::InitializeTask, this, host, status_cb));
 }
 
 scoped_refptr<DemuxerStream> FFmpegDemuxer::GetStream(
     DemuxerStream::Type type) {
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     if (*iter && (*iter)->type() == type) {
       return *iter;
     }
   }
   return NULL;
 }
 
 base::TimeDelta FFmpegDemuxer::GetStartTime() const {
   return start_time_;
 }
 
 size_t FFmpegDemuxer::Read(size_t size, uint8* data) {
+  DCHECK(host_);
   DCHECK(data_source_);
 
   // If read has ever failed, return with an error.
   // TODO(hclam): use a more meaningful constant as error.
   if (read_has_failed_)
     return AVERROR(EIO);
 
   // Even though FFmpeg defines AVERROR_EOF, it's not to be used with I/O
   // routines.  Instead return 0 for any read at or past EOF.
   int64 file_size;
   if (data_source_->GetSize(&file_size) && read_position_ >= file_size)
     return 0;
 
   // Asynchronous read from data source.
   data_source_->Read(read_position_, size, data, base::Bind(
       &FFmpegDemuxer::SignalReadCompleted, 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.
   int last_read_bytes = WaitForRead();
   if (last_read_bytes == DataSource::kReadError) {
-    host()->OnDemuxerError(PIPELINE_ERROR_READ);
+    host_->OnDemuxerError(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;
-  host()->SetCurrentReadPosition(read_position_);
+  host_->SetCurrentReadPosition(read_position_);
 
   return last_read_bytes;
 }
 
 bool FFmpegDemuxer::GetPosition(int64* position_out) {
+  DCHECK(host_);
   *position_out = read_position_;
   return true;
 }
 
 bool FFmpegDemuxer::SetPosition(int64 position) {
+  DCHECK(host_);
   DCHECK(data_source_);
 
   int64 file_size;
   if ((data_source_->GetSize(&file_size) && position >= file_size) ||
       position < 0) {
     return false;
   }
 
   read_position_ = position;
   return true;
 }
 
 bool FFmpegDemuxer::GetSize(int64* size_out) {
+  DCHECK(host_);
   DCHECK(data_source_);
-
   return data_source_->GetSize(size_out);
 }
 
 bool FFmpegDemuxer::IsStreaming() {
+  DCHECK(host_);
   DCHECK(data_source_);
-
   return data_source_->IsStreaming();
 }
 
 MessageLoop* FFmpegDemuxer::message_loop() {
   return message_loop_;
 }
 
 // Helper for calculating the bitrate of the media based on information stored
 // in |format_context| or failing that the size and duration of the media.
 //
@@ skipping 23 matching lines @@
     return 0;
   }
 
   // Do math in floating point as we'd overflow an int64 if the filesize was
   // larger than ~1073GB.
   double bytes = filesize_in_bytes;
   double duration_us = duration.InMicroseconds();
   return bytes * 8000000.0 / duration_us;
 }
 
-void FFmpegDemuxer::InitializeTask(const PipelineStatusCB& status_cb) {
+void FFmpegDemuxer::InitializeTask(DemuxerHost* host,
+                                   const PipelineStatusCB& status_cb) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
+  host_ = host;
+
+  // TODO(scherkus): DataSource should have a host by this point,
+  // see http://crbug.com/122071
+  data_source_->set_host(host);
 
   // 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;
   int result = avformat_open_input(&context, key.c_str(), NULL, NULL);
 
   // Remove ourself from protocol list.
@@ skipping 68 matching lines @@
     max_duration = kInfiniteDuration();
   }
 
   // Some demuxers, like WAV, do not put timestamps on their frames. We
   // assume the the start time is 0.
   if (start_time_ == kNoTimestamp())
     start_time_ = base::TimeDelta();
 
   // Good to go: set the duration and bitrate and notify we're done
   // initializing.
-  host()->SetDuration(max_duration);
+  host_->SetDuration(max_duration);
 
   int64 filesize_in_bytes = 0;
   GetSize(&filesize_in_bytes);
   bitrate_ = CalculateBitrate(format_context_, max_duration, filesize_in_bytes);
   if (bitrate_ > 0)
     data_source_->SetBitrate(bitrate_);
 
   status_cb.Run(PIPELINE_OK);
 }
 
@@ skipping 154 matching lines @@
   read_event_.Wait();
   return last_read_bytes_;
 }
 
 void FFmpegDemuxer::SignalReadCompleted(int size) {
   last_read_bytes_ = size;
   read_event_.Signal();
 }
 
 }  // namespace media