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

media/base/composite_filter.cc

Index: media/base/composite_filter.cc
diff --git a/media/base/composite_filter.cc b/media/base/composite_filter.cc
index 537d26231bd39d1f236b41b0fb082c44af09e6cf..381c9444fa97e5060c95f8d579afd8f63de2d8cb 100644
--- a/media/base/composite_filter.cc
+++ b/media/base/composite_filter.cc
@@ -4,6 +4,7 @@
 
 #include "media/base/composite_filter.h"
 
+#include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
 #include "media/base/callback.h"
@@ -83,7 +84,7 @@ FilterHost* CompositeFilter::host() {
 void CompositeFilter::Play(FilterCallback* play_callback) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   scoped_ptr<FilterCallback> callback(play_callback);
-  if (callback_.get()) {
+  if (IsOperationPending()) {
     SendErrorToHost(PIPELINE_ERROR_OPERATION_PENDING);
     callback->Run();
     return;
@@ -104,7 +105,7 @@ void CompositeFilter::Play(FilterCallback* play_callback) {
 void CompositeFilter::Pause(FilterCallback* pause_callback) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   scoped_ptr<FilterCallback> callback(pause_callback);
-  if (callback_.get()) {
+  if (IsOperationPending()) {
     SendErrorToHost(PIPELINE_ERROR_OPERATION_PENDING);
     callback->Run();
     return;
@@ -125,7 +126,7 @@ void CompositeFilter::Pause(FilterCallback* pause_callback) {
 void CompositeFilter::Flush(FilterCallback* flush_callback) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   scoped_ptr<FilterCallback> callback(flush_callback);
-  if (callback_.get()) {
+  if (IsOperationPending()) {
     SendErrorToHost(PIPELINE_ERROR_OPERATION_PENDING);
     callback->Run();
     return;
@@ -193,21 +194,19 @@ void CompositeFilter::SetPlaybackRate(float playback_rate) {
 }
 
 void CompositeFilter::Seek(base::TimeDelta time,
-                           FilterCallback* seek_callback) {
+                           const FilterStatusCB& seek_cb) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
-  scoped_ptr<FilterCallback> callback(seek_callback);
-  if (callback_.get()) {
-    SendErrorToHost(PIPELINE_ERROR_OPERATION_PENDING);
-    callback->Run();
+
+  if (IsOperationPending()) {
+    seek_cb.Run(PIPELINE_ERROR_OPERATION_PENDING);
     return;
   } else if (!host() || (state_ != kPaused && state_ != kCreated)) {
-    SendErrorToHost(PIPELINE_ERROR_INVALID_STATE);
-    callback->Run();
+    seek_cb.Run(PIPELINE_ERROR_INVALID_STATE);
     return;
   }
 
   ChangeState(kSeekPending);
-  callback_.reset(callback.release());
+  status_cb_ = seek_cb;
   pending_seek_time_ = time;
   StartSerialCallSequence();
 }
@@ -229,13 +228,12 @@ void CompositeFilter::ChangeState(State new_state) {
 void CompositeFilter::StartSerialCallSequence() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   status_ = PIPELINE_OK;
+  sequence_index_ = 0;
 
   if (!filters_.empty()) {
-    sequence_index_ = 0;
     CallFilter(filters_[sequence_index_],
                NewThreadSafeCallback(&CompositeFilter::SerialCallback));
   } else {
-    sequence_index_ = 0;
     SerialCallback();
   }
 }
@@ -243,15 +241,14 @@ void CompositeFilter::StartSerialCallSequence() {
 void CompositeFilter::StartParallelCallSequence() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   status_ = PIPELINE_OK;
+  sequence_index_ = 0;
 
   if (!filters_.empty()) {
-    sequence_index_ = 0;
     for (size_t i = 0; i < filters_.size(); i++) {
       CallFilter(filters_[i],
                  NewThreadSafeCallback(&CompositeFilter::ParallelCallback));
     }
   } else {
-    sequence_index_ = 0;
     ParallelCallback();
   }
 }
@@ -272,7 +269,8 @@ void CompositeFilter::CallFilter(scoped_refptr<Filter>& filter,
       filter->Stop(callback);
       break;
     case kSeekPending:
-      filter->Seek(pending_seek_time_, callback);
+      filter->Seek(pending_seek_time_,
+                   base::Bind(&CompositeFilter::OnStatusCB, this, callback));
       break;
     default:
       delete callback;
@@ -282,6 +280,11 @@ void CompositeFilter::CallFilter(scoped_refptr<Filter>& filter,
 }
 
 void CompositeFilter::DispatchPendingCallback() {
+  if (!status_cb_.is_null()) {

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

DCHECK not both fields are set?

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

Done.

+    CopyAndResetCB(status_cb_).Run(PIPELINE_OK);
+    return;
+  }
+
   if (callback_.get()) {
     scoped_ptr<FilterCallback> callback(callback_.release());
     callback->Run();
@@ -397,6 +400,12 @@ void CompositeFilter::SendErrorToHost(PipelineStatus error) {
 
 void CompositeFilter::HandleError(PipelineStatus error) {
   DCHECK_NE(error, PIPELINE_OK);
+
+  if (!status_cb_.is_null()) {

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

This duplicates code in DispatchPendingCallback.
Can you avoid this?

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

Done. Merge functionality into DispatchPendingCallback.

+    CopyAndResetCB(status_cb_).Run(error);
+    return;
+  }
+
   SendErrorToHost(error);
   DispatchPendingCallback();
 }
@@ -432,6 +441,19 @@ bool CompositeFilter::CanForwardError() {
   return (state_ == kCreated) || (state_ == kPlaying) || (state_ == kPaused);
 }
 
+bool CompositeFilter::IsOperationPending() const {
+  return callback_.get() || !status_cb_.is_null();

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

DCHECK !&& ?

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

Done.

+}
+
+void CompositeFilter::OnStatusCB(FilterCallback* callback,
+                                 PipelineStatus status) {
+  if (status != PIPELINE_OK)
+    SetError(status);
+
+  callback->Run();
+  delete callback;
+}
+
 void CompositeFilter::SetError(PipelineStatus error) {
   // TODO(acolwell): Temporary hack to handle errors that occur
   // during filter initialization. In this case we just forward