Migrate Pipeline & PipelineImpl to PipelineStatusCB.

BUG=90214
TEST=PipelineImplTest.*

Review URL: http://codereview.chromium.org/7484054

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@96096 0039d316-1c4b-4281-b951-d872f2087c98

media/base/mock_filters.cc

@@ -173,10 +173,8 @@ void RunFilterStatusCB(::testing::Unused, const FilterStatusCB& cb) {
   cb.Run(PIPELINE_OK);
 }
 
-void RunPipelineStatusCallback(
-    PipelineStatus status, PipelineStatusCallback* callback) {
-  callback->Run(status);
-  delete callback;
+void RunPipelineStatusCB(PipelineStatus status, const PipelineStatusCB& cb) {
+  cb.Run(status);
 }
 
 void RunFilterCallback3(::testing::Unused, FilterCallback* callback,

media/base/mock_filters.h

@@ -312,8 +312,7 @@ class MockFilterCollection {
 // the Initialize() and Seek() methods.
 void RunFilterCallback(::testing::Unused, FilterCallback* callback);
 void RunFilterStatusCB(::testing::Unused, const FilterStatusCB& cb);
-void RunPipelineStatusCallback(PipelineStatus status,
-                               PipelineStatusCallback* callback);
+void RunPipelineStatusCB(PipelineStatus status, const PipelineStatusCB& cb);
 void RunFilterCallback3(::testing::Unused, FilterCallback* callback,
                         ::testing::Unused);
 

media/base/pipeline.h

@@ -11,7 +11,6 @@
 
 #include <string>
 
-#include "base/callback.h"
 #include "media/base/filters.h"
 #include "media/base/pipeline_status.h"
 
@@ -46,9 +45,9 @@ class Pipeline : public base::RefCountedThreadSafe<Pipeline> {
   // |ended_callback| will be executed when the media reaches the end.
   // |error_callback_| will be executed upon an error in the pipeline.
   // |network_callback_| will be executed when there's a network event.
-  virtual void Init(PipelineStatusCallback* ended_callback,
-                    PipelineStatusCallback* error_callback,
-                    PipelineStatusCallback* network_callback) = 0;
+  virtual void Init(const PipelineStatusCB& ended_callback,
+                    const PipelineStatusCB& error_callback,
+                    const PipelineStatusCB& network_callback) = 0;
 
   // Build a pipeline to render the given URL using the given filter collection
   // to construct a filter chain.  Returns true if successful, false otherwise
@@ -63,7 +62,7 @@ class Pipeline : public base::RefCountedThreadSafe<Pipeline> {
   // pipeline initialization completes.
   virtual bool Start(FilterCollection* filter_collection,
                      const std::string& url,
-                     PipelineStatusCallback* start_callback) = 0;
+                     const PipelineStatusCB& start_callback) = 0;
 
   // Asynchronously stops the pipeline and resets it to an uninitialized state.
   // If provided, |stop_callback| will be executed when the pipeline has been
@@ -75,7 +74,7 @@ class Pipeline : public base::RefCountedThreadSafe<Pipeline> {
   //
   // TODO(scherkus): ideally clients would destroy the pipeline after calling
   // Stop() and create a new pipeline as needed.
-  virtual void Stop(PipelineStatusCallback* stop_callback) = 0;
+  virtual void Stop(const PipelineStatusCB& stop_callback) = 0;
 
   // Attempt to seek to the position specified by time.  |seek_callback| will be
   // executed when the all filters in the pipeline have processed the seek.
@@ -83,7 +82,7 @@ class Pipeline : public base::RefCountedThreadSafe<Pipeline> {
   // Clients are expected to call GetCurrentTime() to check whether the seek
   // succeeded.
   virtual void Seek(base::TimeDelta time,
-                    PipelineStatusCallback* seek_callback) = 0;
+                    const PipelineStatusCB& seek_callback) = 0;
 
   // Returns true if the pipeline has been started via Start().  If IsRunning()
   // returns true, it is expected that Stop() will be called before destroying

media/base/pipeline_impl.cc

@@ -25,15 +25,15 @@ const char kRawMediaScheme[] = "x-raw-media";
 
 PipelineStatusNotification::PipelineStatusNotification()
     : cv_(&lock_), status_(PIPELINE_OK), notified_(false) {
-  callback_.reset(NewCallback(this, &PipelineStatusNotification::Notify));
 }
 
 PipelineStatusNotification::~PipelineStatusNotification() {
   DCHECK(notified_);
 }
 
-media::PipelineStatusCallback* PipelineStatusNotification::Callback() {
-  return callback_.release();
+PipelineStatusCB PipelineStatusNotification::Callback() {
+  return base::Bind(&PipelineStatusNotification::Notify,
+                    base::Unretained(this));
 }
 
 void PipelineStatusNotification::Notify(media::PipelineStatus status) {
@@ -86,22 +86,21 @@ PipelineImpl::~PipelineImpl() {
       media_log_->CreateEvent(MediaLogEvent::PIPELINE_DESTROYED));
 }
 
-void PipelineImpl::Init(PipelineStatusCallback* ended_callback,
-                        PipelineStatusCallback* error_callback,
-                        PipelineStatusCallback* network_callback) {
+void PipelineImpl::Init(const PipelineStatusCB& ended_callback,
+                        const PipelineStatusCB& error_callback,
+                        const PipelineStatusCB& network_callback) {
   DCHECK(!IsRunning())
       << "Init() should be called before the pipeline has started";
-  ended_callback_.reset(ended_callback);
-  error_callback_.reset(error_callback);
-  network_callback_.reset(network_callback);
+  ended_callback_ = ended_callback;
+  error_callback_ = error_callback;
+  network_callback_ = network_callback;
 }
 
 // Creates the PipelineInternal and calls it's start method.
 bool PipelineImpl::Start(FilterCollection* collection,
                          const std::string& url,
-                         PipelineStatusCallback* start_callback) {
+                         const PipelineStatusCB& start_callback) {
   base::AutoLock auto_lock(lock_);
-  scoped_ptr<PipelineStatusCallback> callback(start_callback);
   scoped_ptr<FilterCollection> filter_collection(collection);
 
   if (running_) {
@@ -121,13 +120,12 @@ bool PipelineImpl::Start(FilterCollection* collection,
                         &PipelineImpl::StartTask,
                         filter_collection.release(),
                         url,
-                        callback.release()));
+                        start_callback));
   return true;
 }
 
-void PipelineImpl::Stop(PipelineStatusCallback* stop_callback) {
+void PipelineImpl::Stop(const PipelineStatusCB& stop_callback) {
   base::AutoLock auto_lock(lock_);
-  scoped_ptr<PipelineStatusCallback> callback(stop_callback);
   if (!running_) {
     VLOG(1) << "Media pipeline has already stopped";
     return;
@@ -135,21 +133,19 @@ void PipelineImpl::Stop(PipelineStatusCallback* stop_callback) {
 
   // Stop the pipeline, which will set |running_| to false on behalf.
   message_loop_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &PipelineImpl::StopTask, callback.release()));
+      NewRunnableMethod(this, &PipelineImpl::StopTask, stop_callback));
 }
 
 void PipelineImpl::Seek(base::TimeDelta time,
-                        PipelineStatusCallback* seek_callback) {
+                        const PipelineStatusCB& seek_callback) {
   base::AutoLock auto_lock(lock_);
-  scoped_ptr<PipelineStatusCallback> callback(seek_callback);
   if (!running_) {
     VLOG(1) << "Media pipeline must be running";
     return;
   }
 
   message_loop_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &PipelineImpl::SeekTask, time,
-                        callback.release()));
+      NewRunnableMethod(this, &PipelineImpl::SeekTask, time, seek_callback));
 }
 
 bool PipelineImpl::IsRunning() const {
@@ -428,9 +424,9 @@ void PipelineImpl::FinishInitialization() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   // Execute the seek callback, if present.  Note that this might be the
   // initial callback passed into Start().
-  if (seek_callback_.get()) {
-    seek_callback_->Run(status_);
-    seek_callback_.reset();
+  if (!seek_callback_.is_null()) {
+    seek_callback_.Run(status_);
+    seek_callback_.Reset();
   }
 }
 
@@ -615,12 +611,12 @@ void PipelineImpl::OnUpdateStatistics(const PipelineStatistics& stats) {
 
 void PipelineImpl::StartTask(FilterCollection* filter_collection,
                              const std::string& url,
-                             PipelineStatusCallback* start_callback) {
+                             const PipelineStatusCB& start_callback) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK_EQ(kCreated, state_);
   filter_collection_.reset(filter_collection);
   url_ = url;
-  seek_callback_.reset(start_callback);
+  seek_callback_ = start_callback;
 
   // Kick off initialization.
   pipeline_init_state_.reset(new PipelineInitState());
@@ -754,15 +750,14 @@ void PipelineImpl::InitializeTask() {
 // 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.
-void PipelineImpl::StopTask(PipelineStatusCallback* stop_callback) {
+void PipelineImpl::StopTask(const PipelineStatusCB& stop_callback) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(!IsPipelineStopPending());
   DCHECK_NE(state_, kStopped);
 
   if (state_ == kStopped) {
     // Already stopped so just run callback.
-    stop_callback->Run(status_);
-    delete stop_callback;
+    stop_callback.Run(status_);
     return;
   }
 
@@ -776,7 +771,7 @@ void PipelineImpl::StopTask(PipelineStatusCallback* stop_callback) {
     error_caused_teardown_ = false;
   }
 
-  stop_callback_.reset(stop_callback);
+  stop_callback_ = stop_callback;
 
   stop_pending_ = true;
   if (!IsPipelineSeeking() && !IsPipelineTearingDown()) {
@@ -850,7 +845,7 @@ void PipelineImpl::PreloadChangedTask(Preload preload) {
 }
 
 void PipelineImpl::SeekTask(base::TimeDelta time,
-                            PipelineStatusCallback* seek_callback) {
+                            const PipelineStatusCB& seek_callback) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(!IsPipelineStopPending());
 
@@ -860,7 +855,6 @@ void PipelineImpl::SeekTask(base::TimeDelta time,
     // will only execute the first Seek() request.
     VLOG(1) << "Media pipeline has not started, ignoring seek to "
               << time.InMicroseconds();
-    delete seek_callback;
     return;
   }
 
@@ -876,7 +870,7 @@ void PipelineImpl::SeekTask(base::TimeDelta time,
   //   kStarted
   SetState(kPausing);
   seek_timestamp_ = time;
-  seek_callback_.reset(seek_callback);
+  seek_callback_ = seek_callback;
 
   // Kick off seeking!
   {
@@ -919,15 +913,15 @@ void PipelineImpl::NotifyEndedTask() {
 
   // Transition to ended, executing the callback if present.
   SetState(kEnded);
-  if (ended_callback_.get()) {
-    ended_callback_->Run(status_);
+  if (!ended_callback_.is_null()) {
+    ended_callback_.Run(status_);
   }
 }
 
 void PipelineImpl::NotifyNetworkEventTask() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
-  if (network_callback_.get()) {
-    network_callback_->Run(status_);
+  if (!network_callback_.is_null()) {
+    network_callback_.Run(status_);
   }
 }
 
@@ -1072,16 +1066,17 @@ void PipelineImpl::FinishDestroyingFiltersTask() {
 
   pipeline_filter_ = NULL;
 
-  if (error_caused_teardown_ && !IsPipelineOk() && error_callback_.get())
-    error_callback_->Run(status_);
+  if (error_caused_teardown_ && !IsPipelineOk() && !error_callback_.is_null())
+    error_callback_.Run(status_);
 
   if (stop_pending_) {
     stop_pending_ = false;
     ResetState();
-    scoped_ptr<PipelineStatusCallback> stop_callback(stop_callback_.release());
+    PipelineStatusCB stop_cb;
+    std::swap(stop_cb, stop_callback_);
     // Notify the client that stopping has finished.
-    if (stop_callback.get()) {
-      stop_callback->Run(status_);
+    if (!stop_cb.is_null()) {
+      stop_cb.Run(status_);
     }
   }
 

media/base/pipeline_impl.h

@@ -41,17 +41,17 @@ class PipelineStatusNotification {
   ~PipelineStatusNotification();
 
   // See class-level comment for usage.
-  media::PipelineStatusCallback* Callback();
-  void Notify(media::PipelineStatus status);
+  PipelineStatusCB Callback();
   void Wait();
-  media::PipelineStatus status();
+  PipelineStatus status();
 
  private:
+  void Notify(media::PipelineStatus status);
+
   base::Lock lock_;
   base::ConditionVariable cv_;
   media::PipelineStatus status_;
   bool notified_;
-  scoped_ptr<media::PipelineStatusCallback> callback_;
 
   DISALLOW_COPY_AND_ASSIGN(PipelineStatusNotification);
 };
@@ -98,15 +98,15 @@ class PipelineImpl : public Pipeline, public FilterHost {
   explicit PipelineImpl(MessageLoop* message_loop, MediaLog* media_log);
 
   // Pipeline implementation.
-  virtual void Init(PipelineStatusCallback* ended_callback,
-                    PipelineStatusCallback* error_callback,
-                    PipelineStatusCallback* network_callback);
+  virtual void Init(const PipelineStatusCB& ended_callback,
+                    const PipelineStatusCB& error_callback,
+                    const PipelineStatusCB& network_callback);
   virtual bool Start(FilterCollection* filter_collection,
                      const std::string& uri,
-                     PipelineStatusCallback* start_callback);
-  virtual void Stop(PipelineStatusCallback* stop_callback);
+                     const PipelineStatusCB& start_callback);
+  virtual void Stop(const PipelineStatusCB& stop_callback);
   virtual void Seek(base::TimeDelta time,
-                    PipelineStatusCallback* seek_callback);
+                    const PipelineStatusCB& seek_callback);
   virtual bool IsRunning() const;
   virtual bool IsInitialized() const;
   virtual bool IsNetworkActive() const;
@@ -226,7 +226,7 @@ class PipelineImpl : public Pipeline, public FilterHost {
   // message loop.
   void StartTask(FilterCollection* filter_collection,
                  const std::string& url,
-                 PipelineStatusCallback* start_callback);
+                 const PipelineStatusCB& start_callback);
 
   // InitializeTask() performs initialization in multiple passes. It is executed
   // as a result of calling Start() or InitializationComplete() that advances
@@ -235,7 +235,7 @@ class PipelineImpl : public Pipeline, public FilterHost {
   void InitializeTask();
 
   // Stops and destroys all filters, placing the pipeline in the kStopped state.
-  void StopTask(PipelineStatusCallback* stop_callback);
+  void StopTask(const PipelineStatusCB& stop_callback);
 
   // Carries out stopping and destroying all filters, placing the pipeline in
   // the kError state.
@@ -254,7 +254,7 @@ class PipelineImpl : public Pipeline, public FilterHost {
   void PreloadChangedTask(Preload preload);
 
   // Carries out notifying filters that we are seeking to a new timestamp.
-  void SeekTask(base::TimeDelta time, PipelineStatusCallback* seek_callback);
+  void SeekTask(base::TimeDelta time, const PipelineStatusCB& seek_callback);
 
   // Carries out handling a notification from a filter that it has ended.
   void NotifyEndedTask();
@@ -436,11 +436,11 @@ class PipelineImpl : public Pipeline, public FilterHost {
   std::string url_;
 
   // Callbacks for various pipeline operations.
-  scoped_ptr<PipelineStatusCallback> seek_callback_;
-  scoped_ptr<PipelineStatusCallback> stop_callback_;
-  scoped_ptr<PipelineStatusCallback> ended_callback_;
-  scoped_ptr<PipelineStatusCallback> error_callback_;
-  scoped_ptr<PipelineStatusCallback> network_callback_;
+  PipelineStatusCB seek_callback_;
+  PipelineStatusCB stop_callback_;
+  PipelineStatusCB ended_callback_;
+  PipelineStatusCB error_callback_;
+  PipelineStatusCB network_callback_;
 
   // Reference to the filter(s) that constitute the pipeline.
   scoped_refptr<Filter> pipeline_filter_;

media/base/pipeline_impl_unittest.cc

@@ -4,6 +4,7 @@
 
 #include <string>
 
+#include "base/bind.h"
 #include "base/callback.h"
 #include "base/stl_util.h"
 #include "base/threading/simple_thread.h"
@@ -64,11 +65,9 @@ class PipelineImplTest : public ::testing::Test {
   PipelineImplTest()
       : pipeline_(new PipelineImpl(&message_loop_, new MediaLog())) {
     pipeline_->Init(
-        NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
-                    &CallbackHelper::OnEnded),
-        NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
-                    &CallbackHelper::OnError),
-        static_cast<PipelineStatusCallback*>(NULL));
+        base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
+        base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
+        PipelineStatusCB());
     mocks_.reset(new MockFilterCollection());
 
     // InitializeDemuxer adds overriding expectations for expected non-NULL
@@ -88,8 +87,8 @@ class PipelineImplTest : public ::testing::Test {
 
     // Expect a stop callback if we were started.
     EXPECT_CALL(callbacks_, OnStop(PIPELINE_OK));
-    pipeline_->Stop(NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
-                                &CallbackHelper::OnStop));
+    pipeline_->Stop(base::Bind(&CallbackHelper::OnStop,
+                               base::Unretained(&callbacks_)));
     message_loop_.RunAllPending();
 
     mocks_.reset();
@@ -214,8 +213,8 @@ class PipelineImplTest : public ::testing::Test {
                                                run_build,
                                                build_status),
                      url,
-                     NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
-                                 &CallbackHelper::OnStart));
+                     base::Bind(&CallbackHelper::OnStart,
+                                base::Unretained(&callbacks_)));
 
     message_loop_.RunAllPending();
   }
@@ -261,8 +260,8 @@ class PipelineImplTest : public ::testing::Test {
 
   void DoSeek(const base::TimeDelta& seek_time) {
     pipeline_->Seek(seek_time,
-                    NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
-                                &CallbackHelper::OnSeek));
+                    base::Bind(&CallbackHelper::OnSeek,
+                               base::Unretained(&callbacks_)));
 
     // We expect the time to be updated only after the seek has completed.
     EXPECT_NE(seek_time, pipeline_->GetCurrentTime());
@@ -289,11 +288,11 @@ TEST_F(PipelineImplTest, NotStarted) {
 
   // StrictMock<> will ensure these never get called, and valgrind/purify will
   // make sure the callbacks are instantly deleted.
-  pipeline_->Stop(NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
-                              &CallbackHelper::OnStop));
+  pipeline_->Stop(base::Bind(&CallbackHelper::OnStop,
+                             base::Unretained(&callbacks_)));
   pipeline_->Seek(kZero,
-                  NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
-                              &CallbackHelper::OnSeek));
+                  base::Bind(&CallbackHelper::OnSeek,
+                             base::Unretained(&callbacks_)));
 
   EXPECT_FALSE(pipeline_->IsRunning());
   EXPECT_FALSE(pipeline_->IsInitialized());
@@ -338,8 +337,8 @@ TEST_F(PipelineImplTest, NeverInitializes) {
                                              true,
                                              PIPELINE_OK),
                    "",
-                   NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
-                               &CallbackHelper::OnStart));
+                   base::Bind(&CallbackHelper::OnStart,
+                              base::Unretained(&callbacks_)));
   message_loop_.RunAllPending();
 
   EXPECT_FALSE(pipeline_->IsInitialized());
@@ -366,8 +365,8 @@ TEST_F(PipelineImplTest, RequiredFilterMissing) {
                                 true,
                                 PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
   pipeline_->Start(collection, "",
-                   NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
-                               &CallbackHelper::OnStart));
+                   base::Bind(&CallbackHelper::OnStart,
+                              base::Unretained(&callbacks_)));
   message_loop_.RunAllPending();
 
   EXPECT_FALSE(pipeline_->IsInitialized());
@@ -800,8 +799,8 @@ TEST_F(PipelineImplTest, ErrorDuringSeek) {
   EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, _))
       .WillOnce(Invoke(&SendReadErrorToCB));
 
-  pipeline_->Seek(seek_time, NewCallback(
-      reinterpret_cast<CallbackHelper*>(&callbacks_), &CallbackHelper::OnSeek));
+  pipeline_->Seek(seek_time,base::Bind(&CallbackHelper::OnSeek,
+                                       base::Unretained(&callbacks_)));
   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
   EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_READ));
   message_loop_.RunAllPending();
@@ -851,23 +850,23 @@ TEST_F(PipelineImplTest, StartTimeIsNonZero) {
 class FlexibleCallbackRunner : public base::DelegateSimpleThread::Delegate {
  public:
   FlexibleCallbackRunner(int delayInMs, PipelineStatus status,
-                         PipelineStatusCallback* callback)
+                         const PipelineStatusCB& callback)
       : delayInMs_(delayInMs), status_(status), callback_(callback) {
     if (delayInMs_ < 0) {
-      callback_->Run(status_);
+      callback_.Run(status_);
       return;
     }
   }
   virtual void Run() {
     if (delayInMs_ < 0) return;
     base::PlatformThread::Sleep(delayInMs_);
-    callback_->Run(status_);
+    callback_.Run(status_);
   }
 
  private:
   int delayInMs_;
   PipelineStatus status_;
-  scoped_ptr<PipelineStatusCallback> callback_;
+  PipelineStatusCB callback_;
 };
 
 void TestPipelineStatusNotification(int delayInMs) {

media/base/pipeline_status.h

@@ -34,7 +34,6 @@ enum PipelineStatus {
   DATASOURCE_ERROR_URL_NOT_SUPPORTED,
 };
 
-typedef Callback1<media::PipelineStatus>::Type PipelineStatusCallback;
 typedef base::Callback<void(PipelineStatus)> PipelineStatusCB;
 
 }  // namespace media

media/filters/ffmpeg_demuxer.cc

@@ -331,7 +331,7 @@ void FFmpegDemuxer::set_host(FilterHost* filter_host) {
 }
 
 void FFmpegDemuxer::Initialize(DataSource* data_source,
-                               PipelineStatusCallback* callback) {
+                               const PipelineStatusCB& callback) {
   message_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this,
@@ -426,9 +426,8 @@ MessageLoop* FFmpegDemuxer::message_loop() {
 }
 
 void FFmpegDemuxer::InitializeTask(DataSource* data_source,
-                                   PipelineStatusCallback* callback) {
+                                   const PipelineStatusCB& callback) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
-  scoped_ptr<PipelineStatusCallback> callback_deleter(callback);
 
   data_source_ = data_source;
   if (host())
@@ -446,7 +445,7 @@ void FFmpegDemuxer::InitializeTask(DataSource* data_source,
   FFmpegGlue::GetInstance()->RemoveProtocol(this);
 
   if (result < 0) {
-    callback->Run(DEMUXER_ERROR_COULD_NOT_OPEN);
+    callback.Run(DEMUXER_ERROR_COULD_NOT_OPEN);
     return;
   }
 
@@ -456,7 +455,7 @@ void FFmpegDemuxer::InitializeTask(DataSource* data_source,
   // Fully initialize AVFormatContext by parsing the stream a little.
   result = av_find_stream_info(format_context_);
   if (result < 0) {
-    callback->Run(DEMUXER_ERROR_COULD_NOT_PARSE);
+    callback.Run(DEMUXER_ERROR_COULD_NOT_PARSE);
     return;
   }
 
@@ -497,7 +496,7 @@ void FFmpegDemuxer::InitializeTask(DataSource* data_source,
     }
   }
   if (no_supported_streams) {
-    callback->Run(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
+    callback.Run(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
     return;
   }
   if (format_context_->duration != static_cast<int64_t>(AV_NOPTS_VALUE)) {
@@ -523,7 +522,7 @@ void FFmpegDemuxer::InitializeTask(DataSource* data_source,
   if (host())
     host()->SetDuration(max_duration);
   max_duration_ = max_duration;
-  callback->Run(PIPELINE_OK);
+  callback.Run(PIPELINE_OK);
 }
 
 void FFmpegDemuxer::SeekTask(base::TimeDelta time, const FilterStatusCB& cb) {

media/filters/ffmpeg_demuxer.h

@@ -134,7 +134,7 @@ class FFmpegDemuxer : public Demuxer, public FFmpegURLProtocol {
   virtual void PostDemuxTask();
 
   void Initialize(
-      DataSource* data_source, PipelineStatusCallback* callback);
+      DataSource* data_source, const PipelineStatusCB& callback);
 
   // Filter implementation.
   virtual void Stop(FilterCallback* callback);
@@ -168,7 +168,7 @@ class FFmpegDemuxer : public Demuxer, public FFmpegURLProtocol {
 
   // Carries out initialization on the demuxer thread.
   void InitializeTask(
-      DataSource* data_source, PipelineStatusCallback* callback);
+      DataSource* data_source, const PipelineStatusCB& callback);
 
   // Carries out a seek on the demuxer thread.
   void SeekTask(base::TimeDelta time, const FilterStatusCB& cb);

media/filters/ffmpeg_demuxer_factory.cc

@@ -2,12 +2,26 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "base/bind.h"
 #include "base/message_loop.h"
 #include "media/filters/ffmpeg_demuxer.h"
 #include "media/filters/ffmpeg_demuxer_factory.h"
 
 namespace media {
 
+static void DemuxerInitDone(DemuxerFactory::BuildCallback* cb,
+                            const scoped_refptr<FFmpegDemuxer>& demuxer,
+                            PipelineStatus status) {
+  scoped_ptr<DemuxerFactory::BuildCallback> callback(cb);
+  if (status != PIPELINE_OK) {
+    callback->Run(status, static_cast<Demuxer*>(NULL));
+    return;
+  }
+
+  callback->Run(PIPELINE_OK, demuxer.get());
+}
+
+
 FFmpegDemuxerFactory::FFmpegDemuxerFactory(
     DataSourceFactory* data_source_factory,
     MessageLoop* loop)
@@ -15,34 +29,11 @@ FFmpegDemuxerFactory::FFmpegDemuxerFactory(
 
 FFmpegDemuxerFactory::~FFmpegDemuxerFactory() {}
 
-// This and the next class are one-offs whose raison d'etre is the lack of
-// currying functionality in base/callback_old.h's machinery.  Once media/
-// PipelineStatusCallback and {DataSource,Demuxer}Factory::BuildCallback are
-// migrated to the new base/callback.h machinery these should be removed and
-// replaced with currying calls to base::Bind().
-class DemuxerCallbackAsPipelineStatusCallback : public PipelineStatusCallback {
- public:
-  DemuxerCallbackAsPipelineStatusCallback(
-      DemuxerFactory::BuildCallback* cb,
-      Demuxer* demuxer)
-      : cb_(cb), demuxer_(demuxer) {
-    DCHECK(cb_.get() && demuxer_);
-  }
-
-  virtual ~DemuxerCallbackAsPipelineStatusCallback() {}
-
-  virtual void RunWithParams(const Tuple1<PipelineStatus>& params) {
-    cb_->Run(params.a, demuxer_);
-  }
-
- private:
-  scoped_ptr<DemuxerFactory::BuildCallback> cb_;
-  scoped_refptr<Demuxer> demuxer_;
-
-  DISALLOW_IMPLICIT_CONSTRUCTORS(DemuxerCallbackAsPipelineStatusCallback);
-};
-
-// See comments on DemuxerCallbackAsPipelineStatusCallback above.
+// This class is a one-off whose raison d'etre is the lack of
+// currying functionality in base/callback_old.h's machinery.  Once
+// {DataSource,Demuxer}Factory::BuildCallback are migrated to the new
+// base/callback.h machinery these should be removed and replaced
+// with currying calls to base::Bind().
 class DemuxerCallbackAsDataSourceCallback
     : public DataSourceFactory::BuildCallback {
  public:
@@ -66,7 +57,7 @@ class DemuxerCallbackAsDataSourceCallback
     scoped_refptr<FFmpegDemuxer> demuxer = new FFmpegDemuxer(loop_);
     demuxer->Initialize(
         data_source,
-        new DemuxerCallbackAsPipelineStatusCallback(cb_.release(), demuxer));
+        base::Bind(&DemuxerInitDone, cb_.release(), demuxer));
   }
 
  private:

media/filters/ffmpeg_demuxer_unittest.cc

@@ -147,7 +147,7 @@ class FFmpegDemuxerTest : public testing::Test {
     EXPECT_CALL(host_, SetDuration(expected_duration));
 
     demuxer_->Initialize(data_source_.get(),
-                         NewExpectedStatusCallback(PIPELINE_OK));
+                         NewExpectedStatusCB(PIPELINE_OK));
     message_loop_.RunAllPending();
   }
 
@@ -187,7 +187,7 @@ TEST_F(FFmpegDemuxerTest, Initialize_OpenFails) {
       .WillOnce(Return(-1));
 
   demuxer_->Initialize(data_source_.get(),
-                       NewExpectedStatusCallback(DEMUXER_ERROR_COULD_NOT_OPEN));
+                       NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN));
   message_loop_.RunAllPending();
 }
 
@@ -201,7 +201,7 @@ TEST_F(FFmpegDemuxerTest, Initialize_ParseFails) {
 
   demuxer_->Initialize(
       data_source_.get(),
-      NewExpectedStatusCallback(DEMUXER_ERROR_COULD_NOT_PARSE));
+      NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_PARSE));
   message_loop_.RunAllPending();
 }
 
@@ -215,7 +215,7 @@ TEST_F(FFmpegDemuxerTest, Initialize_NoStreams) {
 
   demuxer_->Initialize(
       data_source_.get(),
-      NewExpectedStatusCallback(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
+      NewExpectedStatusCB(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
   message_loop_.RunAllPending();
 }
 
@@ -230,7 +230,7 @@ TEST_F(FFmpegDemuxerTest, Initialize_DataStreamOnly) {
 
   demuxer_->Initialize(
       data_source_.get(),
-      NewExpectedStatusCallback(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
+      NewExpectedStatusCB(DEMUXER_ERROR_NO_SUPPORTED_STREAMS));
   message_loop_.RunAllPending();
 }
 

media/tools/player_wtl/movie.cc

@@ -132,7 +132,7 @@ void Movie::SetPosition(float position) {
   int64 us = static_cast<int64>(position * 1000000);
   base::TimeDelta time = base::TimeDelta::FromMicroseconds(us);
   if (pipeline_)
-    pipeline_->Seek(time, NULL);
+    pipeline_->Seek(time, media::PipelineStatusCB());
 }
 
 
@@ -174,7 +174,7 @@ bool Movie::GetDumpYuvFileEnable() {
 // Teardown.
 void Movie::Close() {
   if (pipeline_) {
-    pipeline_->Stop(NULL);
+    pipeline_->Stop(media::PipelineStatusCB());
     pipeline_ = NULL;
   }
 

media/tools/player_x11/player_x11.cc

@@ -8,6 +8,7 @@
 #include <X11/Xlib.h>
 
 #include "base/at_exit.h"
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/memory/scoped_ptr.h"
@@ -117,7 +118,7 @@ bool InitPipeline(MessageLoop* message_loop,
   note.Wait();
   if (note.status() != media::PIPELINE_OK) {
     std::cout << "InitPipeline: " << note.status() << std::endl;
-    (*pipeline)->Stop(NULL);
+    (*pipeline)->Stop(media::PipelineStatusCB());
     return false;
   }
 
@@ -138,7 +139,8 @@ void PeriodicalUpdate(
     // interrupt signal was received during last time period.
     // Quit message_loop only when pipeline is fully stopped.
     MessageLoopQuitter* quitter = new MessageLoopQuitter(message_loop);
-    pipeline->Stop(NewCallback(quitter, &MessageLoopQuitter::Quit));
+    pipeline->Stop(base::Bind(&MessageLoopQuitter::Quit,
+                              base::Unretained(quitter)));
     return;
   }
 
@@ -162,7 +164,7 @@ void PeriodicalUpdate(
                        &border_width,
                        &depth);
           base::TimeDelta time = pipeline->GetMediaDuration();
-          pipeline->Seek(time*e.xbutton.x/width, NULL);
+          pipeline->Seek(time*e.xbutton.x/width, media::PipelineStatusCB());
         }
         break;
       case KeyPress:
@@ -172,7 +174,8 @@ void PeriodicalUpdate(
             g_running = false;
             // Quit message_loop only when pipeline is fully stopped.
             MessageLoopQuitter* quitter = new MessageLoopQuitter(message_loop);
-            pipeline->Stop(NewCallback(quitter, &MessageLoopQuitter::Quit));
+            pipeline->Stop(base::Bind(&MessageLoopQuitter::Quit,
+                                      base::Unretained(quitter)));
             return;
           } else if (key == XK_space) {
             if (pipeline->GetPlaybackRate() < 0.01f) // paused

webkit/glue/media/buffered_data_source.cc

@@ -50,7 +50,6 @@ BufferedDataSource::BufferedDataSource(
       frame_(frame),
       loader_(NULL),
       network_activity_(false),
-      initialize_callback_(NULL),
       read_callback_(NULL),
       read_position_(0),
       read_size_(0),
@@ -91,23 +90,21 @@ void BufferedDataSource::set_host(media::FilterHost* host) {
 }
 
 void BufferedDataSource::Initialize(const std::string& url,
-                                    media::PipelineStatusCallback* callback) {
+                                    const media::PipelineStatusCB& callback) {
   // Saves the url.
   url_ = GURL(url);
 
   // This data source doesn't support data:// protocol so reject it.
   if (url_.SchemeIs(kDataScheme)) {
-    callback->Run(media::DATASOURCE_ERROR_URL_NOT_SUPPORTED);
-    delete callback;
+    callback.Run(media::DATASOURCE_ERROR_URL_NOT_SUPPORTED);
     return;
   } else if (!IsProtocolSupportedForMedia(url_)) {
-    callback->Run(media::PIPELINE_ERROR_NETWORK);
-    delete callback;
+    callback.Run(media::PIPELINE_ERROR_NETWORK);
     return;
   }
 
-  DCHECK(callback);
-  initialize_callback_.reset(callback);
+  DCHECK(!callback.is_null());
+  initialize_cb_ = callback;
 
   // Post a task to complete the initialization task.
   render_loop_->PostTask(FROM_HERE,
@@ -116,9 +113,9 @@ void BufferedDataSource::Initialize(const std::string& url,
 
 void BufferedDataSource::CancelInitialize() {
   base::AutoLock auto_lock(lock_);
-  DCHECK(initialize_callback_.get());
+  DCHECK(!initialize_cb_.is_null());
 
-  initialize_callback_.reset();
+  initialize_cb_.Reset();
 
   render_loop_->PostTask(
       FROM_HERE, NewRunnableMethod(this, &BufferedDataSource::CleanupTask));
@@ -208,7 +205,7 @@ void BufferedDataSource::Abort() {
 void BufferedDataSource::InitializeTask() {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(!loader_.get());
-  if (stopped_on_render_loop_ || !initialize_callback_.get())
+  if (stopped_on_render_loop_ || initialize_cb_.is_null())
     return;
 
   if (url_.SchemeIs(kHttpScheme) || url_.SchemeIs(kHttpsScheme)) {
@@ -385,12 +382,11 @@ void BufferedDataSource::DoneRead_Locked(int error) {
 void BufferedDataSource::DoneInitialization_Locked(
     media::PipelineStatus status) {
   DCHECK(MessageLoop::current() == render_loop_);
-  DCHECK(initialize_callback_.get());
+  DCHECK(!initialize_cb_.is_null());
   lock_.AssertAcquired();
 
-  scoped_ptr<media::PipelineStatusCallback> initialize_callback(
-      initialize_callback_.release());
-  initialize_callback->Run(status);
+  initialize_cb_.Run(status);
+  initialize_cb_.Reset();
 }
 
 /////////////////////////////////////////////////////////////////////////////
@@ -402,7 +398,7 @@ void BufferedDataSource::HttpInitialStartCallback(int error) {
   int64 instance_size = loader_->instance_size();
   bool success = error == net::OK;
 
-  if (!initialize_callback_.get()) {
+  if (initialize_cb_.is_null()) {
     loader_->Stop();
     return;
   }
@@ -432,7 +428,7 @@ void BufferedDataSource::HttpInitialStartCallback(int error) {
     return;
   }
 
-  // Reference to prevent destruction while inside the |initialize_callback_|
+  // Reference to prevent destruction while inside the |initialize_cb_|
   // call. This is a temporary fix to prevent crashes caused by holding the
   // lock and running the destructor.
   // TODO: Review locking in this class and figure out a way to run the callback
@@ -465,7 +461,7 @@ void BufferedDataSource::NonHttpInitialStartCallback(int error) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
-  if (!initialize_callback_.get()) {
+  if (initialize_cb_.is_null()) {
     loader_->Stop();
     return;
   }
@@ -481,7 +477,7 @@ void BufferedDataSource::NonHttpInitialStartCallback(int error) {
     loader_->Stop();
   }
 
-  // Reference to prevent destruction while inside the |initialize_callback_|
+  // Reference to prevent destruction while inside the |initialize_cb_|
   // call. This is a temporary fix to prevent crashes caused by holding the
   // lock and running the destructor.
   // TODO: Review locking in this class and figure out a way to run the callback
@@ -497,7 +493,7 @@ void BufferedDataSource::NonHttpInitialStartCallback(int error) {
     // this object when Stop() method is ever called. Locking this method is
     // safe because |lock_| is only acquired in tasks on render thread.
     base::AutoLock auto_lock(lock_);
-    if (stop_signal_received_ || !initialize_callback_.get())
+    if (stop_signal_received_ || initialize_cb_.is_null())
       return;
 
     if (!success) {

webkit/glue/media/buffered_data_source.h

@@ -51,7 +51,7 @@ class BufferedDataSource : public WebDataSource {
 
   // webkit_glue::WebDataSource implementation.
   virtual void Initialize(const std::string& url,
-                          media::PipelineStatusCallback* callback);
+                          const media::PipelineStatusCB& callback);
   virtual void CancelInitialize();
   virtual bool HasSingleOrigin();
   virtual void Abort();
@@ -98,7 +98,7 @@ class BufferedDataSource : public WebDataSource {
   // Calls |read_callback_| and reset all read parameters.
   void DoneRead_Locked(int error);
 
-  // Calls |initialize_callback_| and reset it.
+  // Calls |initialize_cb_| and reset it.
   void DoneInitialization_Locked(media::PipelineStatus status);
 
   // Callback method for |loader_| if URL for the resource requested is using
@@ -154,7 +154,7 @@ class BufferedDataSource : public WebDataSource {
   bool network_activity_;
 
   // Callback method from the pipeline for initialization.
-  scoped_ptr<media::PipelineStatusCallback> initialize_callback_;
+  media::PipelineStatusCB initialize_cb_;
 
   // Read parameters received from the Read() method call.
   scoped_ptr<media::DataSource::ReadCallback> read_callback_;

webkit/glue/media/buffered_data_source_unittest.cc

@@ -198,7 +198,7 @@ class BufferedDataSourceTest : public testing::Test {
 
     // Actual initialization of the data source.
     data_source_->Initialize(url,
-        media::NewExpectedStatusCallback(expected_init_status));
+        media::NewExpectedStatusCB(expected_init_status));
     message_loop_->RunAllPending();
 
     if (initialized_ok) {

webkit/glue/media/simple_data_source.cc

@@ -83,17 +83,17 @@ void SimpleDataSource::Stop(media::FilterCallback* callback) {
 
 void SimpleDataSource::Initialize(
     const std::string& url,
-    media::PipelineStatusCallback* callback) {
-  // Reference to prevent destruction while inside the |initialize_callback_|
+    const media::PipelineStatusCB& callback) {
+  // Reference to prevent destruction while inside the |initialize_cb_|
   // call. This is a temporary fix to prevent crashes caused by holding the
   // lock and running the destructor.
   scoped_refptr<SimpleDataSource> destruction_guard(this);
   {
     base::AutoLock auto_lock(lock_);
     DCHECK_EQ(state_, UNINITIALIZED);
-    DCHECK(callback);
+    DCHECK(!callback.is_null());
     state_ = INITIALIZING;
-    initialize_callback_.reset(callback);
+    initialize_cb_ = callback;
 
     // Validate the URL.
     url_ = GURL(url);
@@ -110,9 +110,9 @@ void SimpleDataSource::Initialize(
 
 void SimpleDataSource::CancelInitialize() {
   base::AutoLock auto_lock(lock_);
-  DCHECK(initialize_callback_.get());
+  DCHECK(!initialize_cb_.is_null());
   state_ = STOPPED;
-  initialize_callback_.reset();
+  initialize_cb_.Reset();
 
   // Post a task to the render thread to cancel loading the resource.
   render_loop_->PostTask(FROM_HERE,
@@ -205,7 +205,7 @@ void SimpleDataSource::didFinishLoading(
     WebKit::WebURLLoader* loader,
     double finishTime) {
   DCHECK(MessageLoop::current() == render_loop_);
-  // Reference to prevent destruction while inside the |initialize_callback_|
+  // Reference to prevent destruction while inside the |initialize_cb_|
   // call. This is a temporary fix to prevent crashes caused by holding the
   // lock and running the destructor.
   scoped_refptr<SimpleDataSource> destruction_guard(this);
@@ -233,7 +233,7 @@ void SimpleDataSource::didFail(
     WebKit::WebURLLoader* loader,
     const WebKit::WebURLError& error) {
   DCHECK(MessageLoop::current() == render_loop_);
-  // Reference to prevent destruction while inside the |initialize_callback_|
+  // Reference to prevent destruction while inside the |initialize_cb_|
   // call. This is a temporary fix to prevent crashes caused by holding the
   // lock and running the destructor.
   scoped_refptr<SimpleDataSource> destruction_guard(this);
@@ -269,7 +269,7 @@ void SimpleDataSource::Abort() {
 
 void SimpleDataSource::StartTask() {
   DCHECK(MessageLoop::current() == render_loop_);
-  // Reference to prevent destruction while inside the |initialize_callback_|
+  // Reference to prevent destruction while inside the |initialize_cb_|
   // call. This is a temporary fix to prevent crashes caused by holding the
   // lock and running the destructor.
   scoped_refptr<SimpleDataSource> destruction_guard(this);
@@ -344,9 +344,8 @@ void SimpleDataSource::DoneInitialization_Locked(bool success) {
     url_loader_.reset();
   }
 
-  scoped_ptr<media::PipelineStatusCallback> initialize_callback(
-      initialize_callback_.release());
-  initialize_callback->Run(status);
+  initialize_cb_.Run(status);
+  initialize_cb_.Reset();
 }
 
 void SimpleDataSource::UpdateHostState() {

webkit/glue/media/simple_data_source.h

@@ -93,7 +93,7 @@ class SimpleDataSource
 
   // webkit_glue::WebDataSource implementation.
   virtual void Initialize(const std::string& url,
-                          media::PipelineStatusCallback* callback);
+                          const media::PipelineStatusCB& callback);
   virtual void CancelInitialize();
   virtual bool HasSingleOrigin();
   virtual void Abort();
@@ -138,7 +138,7 @@ class SimpleDataSource
   base::Lock lock_;
 
   // Filter callbacks.
-  scoped_ptr<media::PipelineStatusCallback> initialize_callback_;
+  media::PipelineStatusCB initialize_cb_;
 
   // Used to ensure mocks for unittests are used instead of reset in Start().
   bool keep_test_loader_;

webkit/glue/media/simple_data_source_unittest.cc

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "base/bind.h"
 #include "media/base/filters.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_filter_host.h"
@@ -64,7 +65,7 @@ class SimpleDataSourceTest : public testing::Test {
   }
 
   void InitializeDataSource(const char* url,
-                            media::MockStatusCallback* callback) {
+                            const media::PipelineStatusCB& callback) {
     gurl_ = GURL(url);
 
     url_loader_ = new NiceMock<MockWebURLLoader>();
@@ -164,21 +165,21 @@ class SimpleDataSourceTest : public testing::Test {
 
 TEST_F(SimpleDataSourceTest, InitializeHTTP) {
   InitializeDataSource(kHttpUrl,
-                       media::NewExpectedStatusCallback(media::PIPELINE_OK));
+                       media::NewExpectedStatusCB(media::PIPELINE_OK));
   RequestSucceeded(false);
   DestroyDataSource();
 }
 
 TEST_F(SimpleDataSourceTest, InitializeHTTPS) {
   InitializeDataSource(kHttpsUrl,
-                       media::NewExpectedStatusCallback(media::PIPELINE_OK));
+                       media::NewExpectedStatusCB(media::PIPELINE_OK));
   RequestSucceeded(false);
   DestroyDataSource();
 }
 
 TEST_F(SimpleDataSourceTest, InitializeFile) {
   InitializeDataSource(kFileUrl,
-                       media::NewExpectedStatusCallback(media::PIPELINE_OK));
+                       media::NewExpectedStatusCB(media::PIPELINE_OK));
   RequestSucceeded(true);
   DestroyDataSource();
 }
@@ -197,7 +198,7 @@ TEST_F(SimpleDataSourceTest, InitializeData) {
   EXPECT_CALL(host_, SetBufferedBytes(sizeof(kDataUrlDecoded)));
 
   data_source_->Initialize(kDataUrl,
-      media::NewExpectedStatusCallback(media::PIPELINE_OK));
+      media::NewExpectedStatusCB(media::PIPELINE_OK));
   MessageLoop::current()->RunAllPending();
 
   DestroyDataSource();
@@ -205,27 +206,29 @@ TEST_F(SimpleDataSourceTest, InitializeData) {
 
 TEST_F(SimpleDataSourceTest, RequestFailed) {
   InitializeDataSource(kHttpUrl,
-      media::NewExpectedStatusCallback(media::PIPELINE_ERROR_NETWORK));
+      media::NewExpectedStatusCB(media::PIPELINE_ERROR_NETWORK));
   RequestFailed();
   DestroyDataSource();
 }
 
+static void OnStatusCB(bool* called, media::PipelineStatus status) {
+  *called = true;
+}
+
 TEST_F(SimpleDataSourceTest, StopWhenDownloading) {
   // The callback should be deleted, but not executed.
   // TODO(scherkus): should this really be the behaviour?  Seems strange...
-  StrictMock<media::MockStatusCallback>* callback =
-      new StrictMock<media::MockStatusCallback>();
-  EXPECT_CALL(*callback, Destructor());
-
-  InitializeDataSource(kHttpUrl, callback);
+  bool was_called = false;
+  InitializeDataSource(kHttpUrl, base::Bind(&OnStatusCB, &was_called));
 
   EXPECT_CALL(*url_loader_, cancel());
   DestroyDataSource();
+  EXPECT_FALSE(was_called);
 }
 
 TEST_F(SimpleDataSourceTest, AsyncRead) {
   InitializeDataSource(kFileUrl,
-                       media::NewExpectedStatusCallback(media::PIPELINE_OK));
+                       media::NewExpectedStatusCB(media::PIPELINE_OK));
   RequestSucceeded(true);
   AsyncRead();
   DestroyDataSource();
@@ -237,14 +240,14 @@ TEST_F(SimpleDataSourceTest, AsyncRead) {
 TEST_F(SimpleDataSourceTest, HasSingleOrigin) {
   // Make sure no redirect case works as expected.
   InitializeDataSource(kHttpUrl,
-                       media::NewExpectedStatusCallback(media::PIPELINE_OK));
+                       media::NewExpectedStatusCB(media::PIPELINE_OK));
   RequestSucceeded(false);
   EXPECT_TRUE(data_source_->HasSingleOrigin());
   DestroyDataSource();
 
   // Test redirect to the same domain.
   InitializeDataSource(kHttpUrl,
-                       media::NewExpectedStatusCallback(media::PIPELINE_OK));
+                       media::NewExpectedStatusCB(media::PIPELINE_OK));
   Redirect(kHttpRedirectToSameDomainUrl1);
   RequestSucceeded(false);
   EXPECT_TRUE(data_source_->HasSingleOrigin());
@@ -252,7 +255,7 @@ TEST_F(SimpleDataSourceTest, HasSingleOrigin) {
 
   // Test redirect twice to the same domain.
   InitializeDataSource(kHttpUrl,
-                       media::NewExpectedStatusCallback(media::PIPELINE_OK));
+                       media::NewExpectedStatusCB(media::PIPELINE_OK));
   Redirect(kHttpRedirectToSameDomainUrl1);
   Redirect(kHttpRedirectToSameDomainUrl2);
   RequestSucceeded(false);
@@ -261,7 +264,7 @@ TEST_F(SimpleDataSourceTest, HasSingleOrigin) {
 
   // Test redirect to a different domain.
   InitializeDataSource(kHttpUrl,
-                       media::NewExpectedStatusCallback(media::PIPELINE_OK));
+                       media::NewExpectedStatusCB(media::PIPELINE_OK));
   Redirect(kHttpRedirectToDifferentDomainUrl1);
   RequestSucceeded(false);
   EXPECT_FALSE(data_source_->HasSingleOrigin());
@@ -269,7 +272,7 @@ TEST_F(SimpleDataSourceTest, HasSingleOrigin) {
 
   // Test redirect to the same domain and then to a different domain.
   InitializeDataSource(kHttpUrl,
-                       media::NewExpectedStatusCallback(media::PIPELINE_OK));
+                       media::NewExpectedStatusCB(media::PIPELINE_OK));
   Redirect(kHttpRedirectToSameDomainUrl1);
   Redirect(kHttpRedirectToDifferentDomainUrl1);
   RequestSucceeded(false);

webkit/glue/media/web_data_source.h

@@ -21,7 +21,7 @@ class WebDataSource : public media::DataSource {
   // Initialize this object using |url|. This object calls |callback| when
   // initialization has completed.
   virtual void Initialize(const std::string& url,
-                          media::PipelineStatusCallback* callback) = 0;
+                          const media::PipelineStatusCB& callback) = 0;
 
   // Called to cancel initialization. The callback passed in Initialize() will
   // be destroyed and will not be called after this method returns. Once this

webkit/glue/media/web_data_source_factory.cc

@@ -4,6 +4,7 @@
 
 #include "webkit/glue/media/web_data_source_factory.h"
 
+#include "base/bind.h"
 #include "base/logging.h"
 #include "media/base/media_log.h"
 
@@ -86,7 +87,8 @@ WebDataSourceFactory::BuildRequest::~BuildRequest() {
 }
 
 void WebDataSourceFactory::BuildRequest::DoStart() {
-  data_source_->Initialize(url(), NewCallback(this, &BuildRequest::InitDone));
+  data_source_->Initialize(url(), base::Bind(&BuildRequest::InitDone,
+                                             base::Unretained(this)));
 }
 
 void WebDataSourceFactory::BuildRequest::InitDone(

webkit/glue/webmediaplayer_impl.cc

@@ -132,12 +132,12 @@ bool WebMediaPlayerImpl::Initialize(
 
   // Set our pipeline callbacks.
   pipeline_->Init(
-      NewCallback(proxy_.get(),
-                  &WebMediaPlayerProxy::PipelineEndedCallback),
-      NewCallback(proxy_.get(),
-                  &WebMediaPlayerProxy::PipelineErrorCallback),
-      NewCallback(proxy_.get(),
-                  &WebMediaPlayerProxy::NetworkEventCallback));
+      base::Bind(&WebMediaPlayerProxy::PipelineEndedCallback,
+                 proxy_.get()),
+      base::Bind(&WebMediaPlayerProxy::PipelineErrorCallback,
+                 proxy_.get()),
+      base::Bind(&WebMediaPlayerProxy::NetworkEventCallback,
+                 proxy_.get()));
 
   // A simple data source that keeps all data in memory.
   scoped_ptr<media::DataSourceFactory> simple_data_source_factory(
@@ -232,8 +232,9 @@ void WebMediaPlayerImpl::load(const WebKit::WebURL& url) {
   pipeline_->Start(
       filter_collection_.release(),
       url.spec(),
-      NewCallback(proxy_.get(),
-                  &WebMediaPlayerProxy::PipelineInitializationCallback));
+      base::Bind(&WebMediaPlayerProxy::PipelineInitializationCallback,
+                 proxy_.get()));
+
   media_log_->AddEvent(media_log_->CreateLoadEvent(url.spec()));
 }
 
@@ -301,8 +302,8 @@ void WebMediaPlayerImpl::seek(float seconds) {
   // Kick off the asynchronous seek!
   pipeline_->Seek(
       seek_time,
-      NewCallback(proxy_.get(),
-                  &WebMediaPlayerProxy::PipelineSeekCallback));
+      base::Bind(&WebMediaPlayerProxy::PipelineSeekCallback,
+                 proxy_.get()));
 }
 
 void WebMediaPlayerImpl::setEndTime(float seconds) {