Convert Filter::Seek() to use new callback system.

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 "media/base/pipeline_impl.h"
 
 #include <algorithm>
 
+#include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/stl_util-inl.h"
 #include "base/synchronization/condition_variable.h"
 #include "media/filters/rtc_video_decoder.h"
 #include "media/base/clock.h"
 #include "media/base/filter_collection.h"
 #include "media/base/media_format.h"
 
 namespace media {
@@ skipping 546 matching lines @@
   message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &PipelineImpl::InitializeTask));
 }
 
 // Called from any thread.
 void PipelineImpl::OnFilterStateTransition() {
   message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &PipelineImpl::FilterStateTransitionTask));
 }
 
+// Called from any thread.
+void PipelineImpl::OnFilterStateTransitionWithStatus(PipelineStatus status) {
+  if (status != PIPELINE_OK)
+    SetError(status);

[Ami GONE FROM CHROMIUM, 2011/05/12 20:42:16]

This is funky b/c it posts the errorchanged task, and then OFST() below posts a
FSTT task, which depends on the errorchanged having run.  I guess this is ok
(messageloop must guarantee order of execution, right?), but funky.

[acolwell GONE FROM CHROMIUM, 2011/05/12 22:30:40]

Yes. This is one of the major reasons why I want to get rid of SetError() in
FilterHost. Code depends on this fact that both the callback AND the error get
put on the message loop. A few months ago, I tried to prevent posting to the
message loop if we were on the pipeline thread, but ran into this assumption.

+  OnFilterStateTransition();
+}
+
 void PipelineImpl::OnTeardownStateTransition() {
   message_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &PipelineImpl::TeardownStateTransitionTask));
 }
 
 // Called from any thread.
 void PipelineImpl::OnUpdateStatistics(const PipelineStatistics& stats) {
   base::AutoLock auto_lock(lock_);
   statistics_.audio_bytes_decoded += stats.audio_bytes_decoded;
   statistics_.video_bytes_decoded += stats.video_bytes_decoded;
@@ skipping 115 matching lines @@
     // Initialization was successful, we are now considered paused, so it's safe
     // to set the initial playback rate and volume.
     PreloadChangedTask(GetPreload());
     PlaybackRateChangedTask(GetPlaybackRate());
     VolumeChangedTask(GetVolume());
 
     // Fire the seek request to get the filters to preroll.
     seek_pending_ = true;
     set_state(kSeeking);
     seek_timestamp_ = base::TimeDelta();
-    pipeline_filter_->Seek(seek_timestamp_,
-        NewCallback(this, &PipelineImpl::OnFilterStateTransition));
+    pipeline_filter_->Seek(
+        seek_timestamp_,
+        base::Bind(&PipelineImpl::OnFilterStateTransitionWithStatus, this));
   }
 }
 
 // This method is called as a result of the client calling Pipeline::Stop() or
 // as the result of an error condition.
 // We stop the filters in the reverse order.
 //
 // TODO(scherkus): beware!  this can get posted multiple times since we post
 // Stop() tasks even if we've already stopped.  Perhaps this should no-op for
 // additional calls, however most of this logic will be changing.
@@ skipping 220 matching lines @@
   // Carry out the action for the current state.
   if (TransientState(state_)) {
     if (state_ == kPausing) {
       pipeline_filter_->Pause(
           NewCallback(this, &PipelineImpl::OnFilterStateTransition));
     } else if (state_ == kFlushing) {
       pipeline_filter_->Flush(
           NewCallback(this, &PipelineImpl::OnFilterStateTransition));
     } else if (state_ == kSeeking) {
       pipeline_filter_->Seek(seek_timestamp_,
-          NewCallback(this, &PipelineImpl::OnFilterStateTransition));
+          base::Bind(&PipelineImpl::OnFilterStateTransitionWithStatus, this));
     } else if (state_ == kStarting) {
       pipeline_filter_->Play(
           NewCallback(this, &PipelineImpl::OnFilterStateTransition));
     } else if (state_ == kStopping) {
       pipeline_filter_->Stop(
           NewCallback(this, &PipelineImpl::OnFilterStateTransition));
     } else {
       NOTREACHED() << "Unexpected state: " << state_;
     }
   } else if (state_ == kStarted) {
@@ skipping 307 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