Move VideoDecoder out of media pipeline.

media/base/pipeline.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 "media/base/pipeline.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "media/base/audio_decoder.h"
 #include "media/base/clock.h"
 #include "media/base/composite_filter.h"
-#include "media/base/composite_filter.h"
 #include "media/base/filter_collection.h"
 #include "media/base/filters.h"
 #include "media/base/media_log.h"
 
 namespace media {
 
 PipelineStatusNotification::PipelineStatusNotification()
     : cv_(&lock_), status_(PIPELINE_OK), notified_(false) {
 }
 
@@ skipping 610 matching lines @@
 // TODO(hclam): InitializeTask() is now starting the pipeline asynchronously. It
 // works like a big state change table. If we no longer need to start filters
 // in order, we need to get rid of all the state change.
 void Pipeline::InitializeTask(PipelineStatus last_stage_status) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   if (last_stage_status != PIPELINE_OK) {
     // Currently only VideoDecoders have a recoverable error code.
     if (state_ == kInitVideoDecoder &&
         last_stage_status == DECODER_ERROR_NOT_SUPPORTED) {
-      pipeline_init_state_->composite->RemoveFilter(
-          pipeline_init_state_->video_decoder.get());
       state_ = kInitAudioRenderer;
     } else {
       SetError(last_stage_status);
     }
   }
 
   // If we have received the stop or error signal, return immediately.
   if (IsPipelineStopPending() || IsPipelineStopped() || !IsPipelineOk())
     return;
 
@@ skipping 491 matching lines @@
     clock_->SetTime(demuxer_->GetStartTime(), demuxer_->GetStartTime());
   }
 
   OnFilterInitialize(PIPELINE_OK);
 }
 
 bool Pipeline::InitializeAudioDecoder(
     const scoped_refptr<Demuxer>& demuxer) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
+  DCHECK(demuxer);
 
   scoped_refptr<DemuxerStream> stream =
       demuxer->GetStream(DemuxerStream::AUDIO);
 
   if (!stream)
     return false;
 
   filter_collection_->SelectAudioDecoder(&pipeline_init_state_->audio_decoder);
 
   if (!pipeline_init_state_->audio_decoder) {
     SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
     return false;
   }
 
   pipeline_init_state_->audio_decoder->Initialize(
       stream,
       base::Bind(&Pipeline::OnFilterInitialize, this),
       base::Bind(&Pipeline::OnUpdateStatistics, this));
   return true;
 }
 
 bool Pipeline::InitializeVideoDecoder(
     const scoped_refptr<Demuxer>& demuxer) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
+  DCHECK(demuxer);
 
-  scoped_refptr<DemuxerStream> stream;
+  scoped_refptr<DemuxerStream> stream =
+      demuxer->GetStream(DemuxerStream::VIDEO);
 
-  if (demuxer) {
-    stream = demuxer->GetStream(DemuxerStream::VIDEO);
+  if (!stream)
+    return false;
 
-    if (!stream)
-      return false;
-  }
+  filter_collection_->SelectVideoDecoder(&pipeline_init_state_->video_decoder);
 
-  filter_collection_->SelectVideoDecoder(&video_decoder_);
-
-  if (!video_decoder_) {
+  if (!pipeline_init_state_->video_decoder) {
     SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
     return false;
   }
 
-  if (!PrepareFilter(video_decoder_))
-    return false;
-
-  pipeline_init_state_->video_decoder = video_decoder_;
-  video_decoder_->Initialize(
+  pipeline_init_state_->video_decoder->Initialize(
       stream,
       base::Bind(&Pipeline::OnFilterInitialize, this),
       base::Bind(&Pipeline::OnUpdateStatistics, this));
+
+  video_decoder_ = pipeline_init_state_->video_decoder;
   return true;
 }
 
 bool Pipeline::InitializeAudioRenderer(
     const scoped_refptr<AudioDecoder>& decoder) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
   if (!decoder)
     return false;
@@ skipping 124 matching lines @@
         &Pipeline::OnDemuxerStopDone, this, callback));
     return;
   }
 
   if (pipeline_filter_) {
     pipeline_filter_->Stop(callback);
     return;
   }
 
   callback.Run();
-
 }
 
 void Pipeline::DoSeek(base::TimeDelta seek_timestamp) {
   // TODO(acolwell) : We might be able to convert this if (demuxer_) into a
   // DCHECK(). Further investigation is needed to make sure this won't introduce
   // a bug.
   if (demuxer_) {
     demuxer_->Seek(seek_timestamp, base::Bind(
         &Pipeline::OnDemuxerSeekDone, this, seek_timestamp));
     return;
@@ skipping 48 matching lines @@
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (!waiting_for_clock_update_)
     return;
 
   waiting_for_clock_update_ = false;
   clock_->Play();
 }
 
 }  // namespace media