Replace RunInSeries() and RunInParallel() with CallbackSeries helper class.

media/base/callback_util.h

 // 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.
 
 #ifndef MEDIA_BASE_CALLBACK_UTIL_H_
 #define MEDIA_BASE_CALLBACK_UTIL_H_
 
 #include <queue>
 
 #include "base/callback.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
 #include "media/base/pipeline_status.h"
 
+namespace base {
+class MessageLoopProxy;
+}
+
 namespace media {
 
-typedef base::Callback<void(const base::Closure&)> ClosureFunc;
-typedef base::Callback<void(const PipelineStatusCB&)> PipelineStatusCBFunc;
+// Runs a series of bound functions accepting Closures or PipelineStatusCB.
+// SerialCallbackRunner doesn't use regular Closure/PipelineStatusCBs as it
+// late binds the completion callback as the series progresses.
+class SerialCallbackRunner {
+ public:
+  typedef base::Callback<void(const base::Closure&)> BoundClosure;
+  typedef base::Callback<void(const PipelineStatusCB&)> BoundPipelineStatusCB;
 
-// Executes the closures in FIFO order, executing |done_cb| when the last
-// closure has completed running.
-//
-// All closures (including |done_cb|) are executed on same thread as the
-// calling thread.
-void RunInSeries(scoped_ptr<std::queue<ClosureFunc> > closures,
-                 const base::Closure& done_cb);
+  // Serial queue of bound functions to run.
+  class Queue {

[scherkus (not reviewing), 2012/08/03 20:19:05]

PTAL here + usage in pipeline.cc

+   public:
+    Queue();
+    ~Queue();
 
-// Executes the closures in FIFO order, executing |done_cb| when the last
-// closure has completed running, reporting the final status code.
-//
-// Closures will stop being executed if a previous closure in the series
-// returned an error status and |done_cb| will be executed prematurely.
-//
-// All closures (including |done_cb|) are executed on same thread as the
-// calling thread.
-void RunInSeriesWithStatus(
-    scoped_ptr<std::queue<PipelineStatusCBFunc> > status_cbs,
-    const PipelineStatusCB& done_cb);
+    void Push(const BoundClosure& bound_fn);
+    void Push(const BoundPipelineStatusCB& bound_fn);
 
-// Executes the closures in parallel, executing |done_cb| when all closures have
-// completed running.
-//
-// No attempt is made to parallelize execution of the closures. In other words,
-// this method will run all closures in FIFO order if said closures execute
-// synchronously on the same call stack.
-//
-// All closures (including |done_cb|) are executed on same thread as the
-// calling thread.
-void RunInParallel(scoped_ptr<std::queue<ClosureFunc> > closures,
-                   const base::Closure& done_cb);
+    BoundPipelineStatusCB Pop();
+
+    bool empty() { return bound_fns_.empty(); }
+
+   private:
+    std::queue<BoundPipelineStatusCB> bound_fns_;
+
+    DISALLOW_COPY_AND_ASSIGN(Queue);
+  };
+
+  // Executes the bound functions in series, executing |done_cb| when finished.
+  //
+  // All bound functions are executed on the thread that Run() is called on,
+  // including |done_cb|.
+  //
+  // Deleting the object will prevent execution of any unstarted bound
+  // functions, including |done_cb|.
+  static scoped_ptr<SerialCallbackRunner> Run(
+      scoped_ptr<Queue> bound_fns, const PipelineStatusCB& done_cb);

[Ami GONE FROM CHROMIUM, 2012/08/03 20:31:43]

copy ctor bound_fns per offline convo

+
+ private:
+  friend class scoped_ptr<SerialCallbackRunner>;
+
+  SerialCallbackRunner(
+      scoped_ptr<Queue> bound_fns, const PipelineStatusCB& done_cb);
+  ~SerialCallbackRunner();
+
+  void RunNextInSeries(PipelineStatus last_status);
+
+  base::WeakPtrFactory<SerialCallbackRunner> weak_this_;
+  scoped_refptr<base::MessageLoopProxy> message_loop_;
+  scoped_ptr<Queue> bound_fns_;

[Ami GONE FROM CHROMIUM, 2012/08/03 20:31:43]

can drop the scoped_ptr here too if pass-by-copy.

+  PipelineStatusCB done_cb_;
+
+  DISALLOW_COPY_AND_ASSIGN(SerialCallbackRunner);
+};
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_CALLBACK_UTIL_H_