DemuxerFactory is born!

media/base/pipeline_impl.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.
 //
 // TODO(scherkus): clean up PipelineImpl... too many crazy function names,
 // potential deadlocks, etc...
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/stl_util-inl.h"
@@ skipping 539 matching lines @@
 void PipelineImpl::StartTask(FilterCollection* filter_collection,
                              const std::string& url,
                              PipelineCallback* start_callback) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK_EQ(kCreated, state_);
   filter_collection_.reset(filter_collection);
   url_ = url;
   seek_callback_.reset(start_callback);
 
   // Kick off initialization.
-  set_state(kInitDataSource);
+  set_state(kInitDemuxer);
   pipeline_init_state_.reset(new PipelineInitState());
   pipeline_init_state_->composite_ = new CompositeFilter(message_loop_);
   pipeline_init_state_->composite_->set_host(this);
 
-  InitializeDataSource();
+  InitializeDemuxer();
 }
 
 // Main initialization method called on the pipeline thread.  This code attempts
 // to use the specified filter factory to build a pipeline.
 // Initialization step performed in this method depends on current state of this
 // object, indicated by |state_|.  After each step of initialization, this
-// object transits to the next stage.  It starts by creating a DataSource,
-// connects it to a Demuxer, and then connects the Demuxer's audio stream to an
-// AudioDecoder which is then connected to an AudioRenderer.  If the media has
-// video, then it connects a VideoDecoder to the Demuxer's video stream, and
-// then connects the VideoDecoder to a VideoRenderer.
+// object transits to the next stage.  It starts by creating a Demuxer, and then
+// connects the Demuxer's audio stream to an AudioDecoder which is then
+// connected to an AudioRenderer.  If the media has video, then it connects a
+// VideoDecoder to the Demuxer's video stream, and then connects the
+// VideoDecoder to a VideoRenderer.
 //
 // When all required filters have been created and have called their
 // FilterHost's InitializationComplete() method, the pipeline will update its
 // state to kStarted and |init_callback_|, will be executed.
 //
 // 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 PipelineImpl::InitializeTask() {
+   void PipelineImpl::InitializeTask() {

[acolwell GONE FROM CHROMIUM, 2011/03/08 21:48:09]

Indentation

[Ami GONE FROM CHROMIUM, 2011/03/08 22:44:48]

Done.

   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   // If we have received the stop or error signal, return immediately.
   if (IsPipelineStopPending() ||
       IsPipelineStopped() ||
       PIPELINE_OK != GetError()) {
     return;
   }
 
   DCHECK(state_ == kInitDemuxer ||
@@ skipping 346 matching lines @@
           NewCallback(this, &PipelineImpl::OnTeardownStateTransition));
       break;
     case kFlushing:
       set_state(kStopping);
       pipeline_filter_->Stop(
           NewCallback(this, &PipelineImpl::OnTeardownStateTransition));
       break;
 
     case kCreated:
     case kError:
-    case kInitDataSource:
     case kInitDemuxer:
     case kInitAudioDecoder:
     case kInitAudioRenderer:
     case kInitVideoDecoder:
     case kInitVideoRenderer:
     case kSeeking:
     case kStarting:
     case kStopped:
     case kStarted:
     case kEnded:
@@ skipping 35 matching lines @@
 
 bool PipelineImpl::PrepareFilter(scoped_refptr<Filter> filter) {
   bool ret = pipeline_init_state_->composite_->AddFilter(filter.get());
 
   if (!ret) {
     SetError(PIPELINE_ERROR_INITIALIZATION_FAILED);
   }
   return ret;
 }
 
-void PipelineImpl::InitializeDataSource() {
+void PipelineImpl::InitializeDemuxer() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
-  filter_collection_->GetDataSourceFactory()->Build(url_,
-      NewCallback(this, &PipelineImpl::OnDataSourceBuilt));
+  filter_collection_->GetDemuxerFactory()->Build(url_,
+      NewCallback(this, &PipelineImpl::OnDemuxerBuilt));
 }
 
-void PipelineImpl::OnDataSourceBuilt(PipelineError error,
-                                     DataSource* data_source) {
+void PipelineImpl::OnDemuxerBuilt(PipelineError error,
+                                  Demuxer* demuxer) {
   if (MessageLoop::current() != message_loop_) {
     message_loop_->PostTask(FROM_HERE,
                             NewRunnableMethod(this,
-                                              &PipelineImpl::OnDataSourceBuilt,
+                                              &PipelineImpl::OnDemuxerBuilt,
                                               error,
-                                              make_scoped_refptr(data_source)));
+                                              make_scoped_refptr(demuxer)));
     return;
   }
 
   if (error != PIPELINE_OK) {
     SetError(error);
     return;
   }
 
-  PrepareFilter(data_source);
-
-  set_state(kInitDemuxer);
-  InitializeDemuxer(data_source);
-}
-
-void PipelineImpl::InitializeDemuxer(
-    const scoped_refptr<DataSource>& data_source) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
-  DCHECK(IsPipelineOk());
-
-  scoped_refptr<Demuxer> demuxer;
-
-  CHECK(data_source);
-
-  filter_collection_->SelectDemuxer(&demuxer);
   if (!demuxer) {
     SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
     return;
   }
 
   if (!PrepareFilter(demuxer))
     return;
 
-  pipeline_init_state_->demuxer_ = demuxer;
-  demuxer->Initialize(data_source,
-                      NewCallback(this, &PipelineImpl::OnFilterInitialize));
+  pipeline_init_state_->demuxer_ = make_scoped_refptr(demuxer);

[acolwell GONE FROM CHROMIUM, 2011/03/08 21:48:09]

I don't think you need make_scoped_refptr() here.

[Ami GONE FROM CHROMIUM, 2011/03/08 22:44:48]

Done.

+  OnFilterInitialize();

[acolwell GONE FROM CHROMIUM, 2011/03/08 21:48:09]

I think you can call InitializeTask() from here instead since the check at the
top makes sure you are on the right thread.

[Ami GONE FROM CHROMIUM, 2011/03/08 22:44:48]

But calling OFI() has the additional benefit of decoupling the stacks.  I chose
this way b/c it is more consistent with the rest of the initialization
transitions in this file (continuation-style instead of call-style).

[acolwell GONE FROM CHROMIUM, 2011/03/08 23:19:00]

Ok. Sounds reasonable to me.

 }
 
 bool PipelineImpl::InitializeAudioDecoder(
     const scoped_refptr<Demuxer>& demuxer) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
   scoped_refptr<DemuxerStream> stream =
       FindDemuxerStream(demuxer, mime_type::kMajorTypeAudio);
 
@@ skipping 126 matching lines @@
   switch(state_) {
     case kCreated:
     case kError:
       set_state(kStopped);
       // Need to put this in the message loop to make sure that it comes
       // after any pending callback tasks that are already queued.
       message_loop_->PostTask(FROM_HERE,
           NewRunnableMethod(this, &PipelineImpl::FinishDestroyingFiltersTask));
       break;
 
-    case kInitDataSource:
     case kInitDemuxer:
     case kInitAudioDecoder:
     case kInitAudioRenderer:
     case kInitVideoDecoder:
     case kInitVideoRenderer:
       // Make it look like initialization was successful.
       pipeline_filter_ = pipeline_init_state_->composite_;
       pipeline_init_state_.reset();
       filter_collection_.reset();
 
@@ skipping 29 matching lines @@
     case kStopping:
     case kStopped:
       NOTREACHED() << "Unexpected state for teardown: " << state_;
       break;
     // default: intentionally left out to force new states to cause compiler
     // errors.
   };
 }
 
 }  // namespace media