Splitting media filter's Initialize() into Create() + callback and Seek() + callback.

media/base/pipeline_impl.cc

 // Copyright (c) 2008-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.
 //
 // TODO(scherkus): clean up PipelineImpl... too many crazy function names,
 // potential deadlocks, etc...
 
 #include "base/compiler_specific.h"
 #include "base/condition_variable.h"
 #include "base/stl_util-inl.h"
@@ skipping 310 matching lines @@
       NewRunnableMethod(this, &PipelineInternal::PlaybackRateChangedTask,
                         playback_rate));
 }
 
 // Called on client's thread.
 void PipelineInternal::VolumeChanged(float volume) {
   message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &PipelineInternal::VolumeChangedTask, volume));
 }
 
-// Called from any thread.
-void PipelineInternal::InitializationComplete(FilterHostImpl* host) {
-  if (IsPipelineOk()) {
-    // Continue the initialize task by proceeding to the next stage.
-    message_loop_->PostTask(FROM_HERE,
-        NewRunnableMethod(this, &PipelineInternal::InitializeTask));
-  }
-}
-
 // Called from any thread.  Updates the pipeline time.
 void PipelineInternal::SetTime(base::TimeDelta time) {
   // TODO(scherkus): why not post a task?
   pipeline_->SetTime(time);
 }
 
 // Called from any thread.  Sets the pipeline |error_| member and destroys all
 // filters.
 void PipelineInternal::Error(PipelineError error) {
   message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &PipelineInternal::ErrorTask, error));
 }
 
+// Called from any thread.
+void PipelineInternal::OnFilterInitialize() {
+  // Continue the initialize task by proceeding to the next stage.
+  message_loop_->PostTask(FROM_HERE,
+      NewRunnableMethod(this, &PipelineInternal::InitializeTask));
+}
+
+// Called from any thread.
+void PipelineInternal::OnFilterSeek() {
+  // TODO(scherkus): have PipelineInternal wait to receive replies from every
+  // filter before calling the client's |seek_callback_|.
+}
+
 void PipelineInternal::StartTask(FilterFactory* filter_factory,
                                  const std::string& url,
                                  PipelineCallback* start_callback) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK_EQ(kCreated, state_);
   filter_factory_ = filter_factory;
   url_ = url;
   start_callback_.reset(start_callback);
 
   // Kick off initialization.
@@ skipping 13 matching lines @@
 // 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 PipelineInternal::InitializeTask() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
-  // If we have received the stop signal, return immediately.
-  if (state_ == kStopped)
+  // If we have received the stop or error signal, return immediately.
+  if (state_ == kStopped || state_ == kError)
     return;
 
   DCHECK(state_ == kCreated || IsPipelineInitializing());
 
   // Just created, create data source.
   if (state_ == kCreated) {
     state_ = kInitDataSource;
     CreateDataSource();
     return;
   }
@@ skipping 146 matching lines @@
   seek_callback_.reset(seek_callback);
 
   // Supress seeking if we haven't fully started.
   if (state_ != kStarted) {
     return;
   }
 
   for (FilterHostVector::iterator iter = filter_hosts_.begin();
        iter != filter_hosts_.end();
        ++iter) {
-    (*iter)->media_filter()->Seek(time);
+    (*iter)->media_filter()->Seek(time,
+        NewCallback(this, &PipelineInternal::OnFilterSeek));
   }
 
   // TODO(hclam): we should set the time when the above seek operations were all
   // successful and first frame/packet at the desired time is decoded. I'm
   // setting the time here because once we do the callback the user can ask for
   // current time immediately, which is the old time. In order to get rid this
   // little glitch, we either assume the seek was successful and time is updated
   // immediately here or we set time and do callback when we have new
   // frames/packets.
   SetTime(time);
@@ skipping 30 matching lines @@
     filter_threads_.push_back(thread.release());
   }
 
   // Create the filter's host.
   DCHECK(IsPipelineOk());
   scoped_ptr<FilterHostImpl> host(new FilterHostImpl(this, filter.get()));
   filter->set_host(host.get());
   filter_hosts_.push_back(host.release());
 
   // Now initialize the filter.
-  if (!filter->Initialize(source)) {
-    Error(PIPELINE_ERROR_INITIALIZATION_FAILED);
-  }
+  filter->Initialize(source,
+      NewCallback(this, &PipelineInternal::OnFilterInitialize));
 }
 
 void PipelineInternal::CreateDataSource() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
   MediaFormat url_format;
   url_format.SetAsString(MediaFormat::kMimeType, mime_type::kURL);
   url_format.SetAsString(MediaFormat::kURL, url_);
   CreateFilter<DataSource>(filter_factory_, url_, url_format);
@@ skipping 104 matching lines @@
   }
 
   // Reset the pipeline, which will decrement a reference to this object.
   // We will get destroyed as soon as the remaining tasks finish executing.
   // To be safe, we'll set our pipeline reference to NULL.
   STLDeleteElements(&filter_hosts_);
   STLDeleteElements(&filter_threads_);
 }
 
 }  // namespace media