Convert all of media/ over to the new base::{Bind,Callback} hotness.

Mostly this was a rote conversion, replacing:
- Pass-by-pointer CallbackN<>'s become pass-by-const-ref Callback<>'s.
- scoped_ptr<CallbackN<>> members become Callback<> members.
- several dedicated FooCallback typedefs became base::Closure.

Because it was only used in a small handful of places and only in one place
profitably, I deleted AutoCallbackRunner.

Because it tickles a Bind bug I disabled mfdecoder in .gyp (about to get deleted in a scherkus CL).

BUG=none
TEST=media_tests, trybots

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

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

8 files changed, 61 insertions, 67 deletions

diff --git a/content/renderer/media/audio_renderer_impl.cc b/content/renderer/media/audio_renderer_impl.cc
index 4abad2a..ac6aca0 100644
--- a/content/renderer/media/audio_renderer_impl.cc
+++ b/content/renderer/media/audio_renderer_impl.cc
@@ -168,7 +168,7 @@ void AudioRendererImpl::SetPlaybackRate(float rate) {
   }
 }
 
-void AudioRendererImpl::Pause(media::FilterCallback* callback) {
+void AudioRendererImpl::Pause(const base::Closure& callback) {
   AudioRendererBase::Pause(callback);
   base::AutoLock auto_lock(lock_);
   if (stopped_)
@@ -192,7 +192,7 @@ void AudioRendererImpl::Seek(base::TimeDelta time,
 }
 
 
-void AudioRendererImpl::Play(media::FilterCallback* callback) {
+void AudioRendererImpl::Play(const base::Closure& callback) {
   AudioRendererBase::Play(callback);
   base::AutoLock auto_lock(lock_);
   if (stopped_)
diff --git a/content/renderer/media/audio_renderer_impl.h b/content/renderer/media/audio_renderer_impl.h
index 27b58fb..802e1ae 100644
--- a/content/renderer/media/audio_renderer_impl.h
+++ b/content/renderer/media/audio_renderer_impl.h
@@ -75,9 +75,9 @@ class AudioRendererImpl
   // Methods called on pipeline thread ----------------------------------------
   // media::Filter implementation.
   virtual void SetPlaybackRate(float rate);
-  virtual void Pause(media::FilterCallback* callback);
+  virtual void Pause(const base::Closure& callback);
   virtual void Seek(base::TimeDelta time, const media::FilterStatusCB& cb);
-  virtual void Play(media::FilterCallback* callback);
+  virtual void Play(const base::Closure& callback);
 
   // media::AudioRenderer implementation.
   virtual void SetVolume(float volume);
diff --git a/content/renderer/media/capture_video_decoder.cc b/content/renderer/media/capture_video_decoder.cc
index c7c0b5a..4a356a1 100644
--- a/content/renderer/media/capture_video_decoder.cc
+++ b/content/renderer/media/capture_video_decoder.cc
@@ -22,7 +22,6 @@ CaptureVideoDecoder::CaptureVideoDecoder(
       vc_manager_(vc_manager),
       capability_(capability),
       state_(kUnInitialized),
-      pending_stop_cb_(NULL),
       video_stream_id_(video_stream_id),
       capture_engine_(NULL) {
   DCHECK(vc_manager);
@@ -30,9 +29,10 @@ CaptureVideoDecoder::CaptureVideoDecoder(
 
 CaptureVideoDecoder::~CaptureVideoDecoder() {}
 
-void CaptureVideoDecoder::Initialize(media::DemuxerStream* demuxer_stream,
-                                     media::FilterCallback* filter_callback,
-                                     media::StatisticsCallback* stat_callback) {
+void CaptureVideoDecoder::Initialize(
+    media::DemuxerStream* demuxer_stream,
+    const base::Closure& filter_callback,
+    const media::StatisticsCallback& stat_callback) {
   message_loop_proxy_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this,
@@ -54,7 +54,7 @@ gfx::Size CaptureVideoDecoder::natural_size() {
   return gfx::Size(capability_.width, capability_.height);
 }
 
-void CaptureVideoDecoder::Play(media::FilterCallback* callback) {
+void CaptureVideoDecoder::Play(const base::Closure& callback) {
   message_loop_proxy_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this,
@@ -62,7 +62,7 @@ void CaptureVideoDecoder::Play(media::FilterCallback* callback) {
                         callback));
 }
 
-void CaptureVideoDecoder::Pause(media::FilterCallback* callback) {
+void CaptureVideoDecoder::Pause(const base::Closure& callback) {
   message_loop_proxy_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this,
@@ -70,7 +70,7 @@ void CaptureVideoDecoder::Pause(media::FilterCallback* callback) {
                         callback));
 }
 
-void CaptureVideoDecoder::Stop(media::FilterCallback* callback) {
+void CaptureVideoDecoder::Stop(const base::Closure& callback) {
   message_loop_proxy_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this,
@@ -133,8 +133,8 @@ void CaptureVideoDecoder::OnDeviceInfoReceived(
 
 void CaptureVideoDecoder::InitializeOnDecoderThread(
     media::DemuxerStream* demuxer_stream,
-    media::FilterCallback* filter_callback,
-    media::StatisticsCallback* stat_callback) {
+    const base::Closure& filter_callback,
+    const media::StatisticsCallback& stat_callback) {
   VLOG(1) << "InitializeOnDecoderThread.";
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
 
@@ -142,9 +142,8 @@ void CaptureVideoDecoder::InitializeOnDecoderThread(
 
   available_frames_.clear();
 
-  statistics_callback_.reset(stat_callback);
-  filter_callback->Run();
-  delete filter_callback;
+  statistics_callback_ = stat_callback;
+  filter_callback.Run();
   state_ = kNormal;
 }
 
@@ -154,22 +153,20 @@ void CaptureVideoDecoder::ProduceVideoFrameOnDecoderThread(
   available_frames_.push_back(video_frame);
 }
 
-void CaptureVideoDecoder::PlayOnDecoderThread(media::FilterCallback* callback) {
+void CaptureVideoDecoder::PlayOnDecoderThread(const base::Closure& callback) {
   VLOG(1) << "PlayOnDecoderThread.";
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
-  callback->Run();
-  delete callback;
+  callback.Run();
 }
 
-void CaptureVideoDecoder::PauseOnDecoderThread(
-    media::FilterCallback* callback) {
+void CaptureVideoDecoder::PauseOnDecoderThread(const base::Closure& callback) {
   VLOG(1) << "PauseOnDecoderThread.";
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
   state_ = kPaused;
   media::VideoDecoder::Pause(callback);
 }
 
-void CaptureVideoDecoder::StopOnDecoderThread(media::FilterCallback* callback) {
+void CaptureVideoDecoder::StopOnDecoderThread(const base::Closure& callback) {
   VLOG(1) << "StopOnDecoderThread.";
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
   pending_stop_cb_ = callback;
@@ -199,11 +196,8 @@ void CaptureVideoDecoder::OnStoppedOnDecoderThread(
     media::VideoCapture* capture) {
   VLOG(1) << "OnStoppedOnDecoderThread.";
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
-  if (pending_stop_cb_) {
-    pending_stop_cb_->Run();
-    delete pending_stop_cb_;
-    pending_stop_cb_ = NULL;
-  }
+  if (!pending_stop_cb_.is_null())
+    media::ResetAndRunCB(&pending_stop_cb_);
   vc_manager_->RemoveDevice(video_stream_id_, this);
 }
 
diff --git a/content/renderer/media/capture_video_decoder.h b/content/renderer/media/capture_video_decoder.h
index f491d5e..f616700 100644
--- a/content/renderer/media/capture_video_decoder.h
+++ b/content/renderer/media/capture_video_decoder.h
@@ -32,16 +32,17 @@ class CaptureVideoDecoder
   virtual ~CaptureVideoDecoder();
 
   // Filter implementation.
-  virtual void Play(media::FilterCallback* callback) OVERRIDE;
+  virtual void Play(const base::Closure& callback) OVERRIDE;
   virtual void Seek(base::TimeDelta time,
                     const media::FilterStatusCB& cb) OVERRIDE;
-  virtual void Pause(media::FilterCallback* callback) OVERRIDE;
-  virtual void Stop(media::FilterCallback* callback) OVERRIDE;
+  virtual void Pause(const base::Closure& callback) OVERRIDE;
+  virtual void Stop(const base::Closure& callback) OVERRIDE;
 
   // Decoder implementation.
-  virtual void Initialize(media::DemuxerStream* demuxer_stream,
-                          media::FilterCallback* filter_callback,
-                          media::StatisticsCallback* stat_callback) OVERRIDE;
+  virtual void Initialize(
+      media::DemuxerStream* demuxer_stream,
+      const base::Closure& filter_callback,
+      const media::StatisticsCallback& stat_callback) OVERRIDE;
   virtual void ProduceVideoFrame(
       scoped_refptr<media::VideoFrame> video_frame) OVERRIDE;
   virtual gfx::Size natural_size() OVERRIDE;
@@ -70,15 +71,16 @@ class CaptureVideoDecoder
     kPaused
   };
 
-  void PlayOnDecoderThread(media::FilterCallback* callback);
+  void PlayOnDecoderThread(const base::Closure& callback);
   void SeekOnDecoderThread(base::TimeDelta time,
                            const media::FilterStatusCB& cb);
-  void PauseOnDecoderThread(media::FilterCallback* callback);
-  void StopOnDecoderThread(media::FilterCallback* callback);
+  void PauseOnDecoderThread(const base::Closure& callback);
+  void StopOnDecoderThread(const base::Closure& callback);
 
-  void InitializeOnDecoderThread(media::DemuxerStream* demuxer_stream,
-                                 media::FilterCallback* filter_callback,
-                                 media::StatisticsCallback* stat_callback);
+  void InitializeOnDecoderThread(
+      media::DemuxerStream* demuxer_stream,
+      const base::Closure& filter_callback,
+      const media::StatisticsCallback& stat_callback);
   void ProduceVideoFrameOnDecoderThread(
       scoped_refptr<media::VideoFrame> video_frame);
 
@@ -92,8 +94,8 @@ class CaptureVideoDecoder
   media::VideoCapture::VideoCaptureCapability capability_;
   DecoderState state_;
   std::deque<scoped_refptr<media::VideoFrame> > available_frames_;
-  media::FilterCallback* pending_stop_cb_;
-  scoped_ptr<media::StatisticsCallback> statistics_callback_;
+  base::Closure pending_stop_cb_;
+  media::StatisticsCallback statistics_callback_;
 
   media::VideoCaptureSessionId video_stream_id_;
   media::VideoCapture* capture_engine_;
diff --git a/content/renderer/media/capture_video_decoder_unittest.cc b/content/renderer/media/capture_video_decoder_unittest.cc
index 8e7be2a..a74c305 100644
--- a/content/renderer/media/capture_video_decoder_unittest.cc
+++ b/content/renderer/media/capture_video_decoder_unittest.cc
@@ -114,9 +114,9 @@ class CaptureVideoDecoderTest : public ::testing::Test {
     message_loop_->RunAllPending();
   }
 
-  media::StatisticsCallback* NewStatisticsCallback() {
-    return NewCallback(&statistics_callback_object_,
-                       &media::MockStatisticsCallback::OnStatistics);
+  media::StatisticsCallback NewStatisticsCallback() {
+    return base::Bind(&media::MockStatisticsCallback::OnStatistics,
+                      base::Unretained(&statistics_callback_object_));
   }
 
   // Fixture members.
diff --git a/content/renderer/media/rtc_video_decoder.cc b/content/renderer/media/rtc_video_decoder.cc
index 4722f96..ef9973c 100644
--- a/content/renderer/media/rtc_video_decoder.cc
+++ b/content/renderer/media/rtc_video_decoder.cc
@@ -6,9 +6,10 @@
 
 #include <deque>
 
+#include "base/bind.h"
+#include "base/callback.h"
 #include "base/message_loop.h"
 #include "base/task.h"
-#include "media/base/callback.h"
 #include "media/base/demuxer.h"
 #include "media/base/filter_host.h"
 #include "media/base/filters.h"
@@ -21,7 +22,6 @@ using media::CopyUPlane;
 using media::CopyVPlane;
 using media::CopyYPlane;
 using media::DemuxerStream;
-using media::FilterCallback;
 using media::FilterStatusCB;
 using media::kNoTimestamp;
 using media::Limits;
@@ -41,15 +41,14 @@ RTCVideoDecoder::RTCVideoDecoder(MessageLoop* message_loop,
 RTCVideoDecoder::~RTCVideoDecoder() {}
 
 void RTCVideoDecoder::Initialize(DemuxerStream* demuxer_stream,
-                                 FilterCallback* filter_callback,
-                                 StatisticsCallback* stat_callback) {
+                                 const base::Closure& filter_callback,
+                                 const StatisticsCallback& stat_callback) {
   if (MessageLoop::current() != message_loop_) {
     message_loop_->PostTask(
         FROM_HERE,
-        NewRunnableMethod(this,
-                          &RTCVideoDecoder::Initialize,
-                          make_scoped_refptr(demuxer_stream),
-                          filter_callback, stat_callback));
+        base::Bind(&RTCVideoDecoder::Initialize, this,
+                   make_scoped_refptr(demuxer_stream),
+                   filter_callback, stat_callback));
     return;
   }
 
@@ -61,14 +60,12 @@ void RTCVideoDecoder::Initialize(DemuxerStream* demuxer_stream,
 
   state_ = kNormal;
 
-  filter_callback->Run();
-  delete filter_callback;
+  filter_callback.Run();
 
   // TODO(acolwell): Implement stats.
-  delete stat_callback;
 }
 
-void RTCVideoDecoder::Play(FilterCallback* callback) {
+void RTCVideoDecoder::Play(const base::Closure& callback) {
   if (MessageLoop::current() != message_loop_) {
     message_loop_->PostTask(FROM_HERE,
                              NewRunnableMethod(this,
@@ -82,7 +79,7 @@ void RTCVideoDecoder::Play(FilterCallback* callback) {
   VideoDecoder::Play(callback);
 }
 
-void RTCVideoDecoder::Pause(FilterCallback* callback) {
+void RTCVideoDecoder::Pause(const base::Closure& callback) {
   if (MessageLoop::current() != message_loop_) {
     message_loop_->PostTask(FROM_HERE,
                             NewRunnableMethod(this,
@@ -98,7 +95,7 @@ void RTCVideoDecoder::Pause(FilterCallback* callback) {
   VideoDecoder::Pause(callback);
 }
 
-void RTCVideoDecoder::Stop(FilterCallback* callback) {
+void RTCVideoDecoder::Stop(const base::Closure& callback) {
   if (MessageLoop::current() != message_loop_) {
     message_loop_->PostTask(FROM_HERE,
                             NewRunnableMethod(this,
diff --git a/content/renderer/media/rtc_video_decoder.h b/content/renderer/media/rtc_video_decoder.h
index d3b4196..d5ffb7b 100644
--- a/content/renderer/media/rtc_video_decoder.h
+++ b/content/renderer/media/rtc_video_decoder.h
@@ -30,16 +30,17 @@ class RTCVideoDecoder
   virtual ~RTCVideoDecoder();
 
   // Filter implementation.
-  virtual void Play(media::FilterCallback* callback) OVERRIDE;
+  virtual void Play(const base::Closure& callback) OVERRIDE;
   virtual void Seek(base::TimeDelta time,
                     const media::FilterStatusCB& cb) OVERRIDE;
-  virtual void Pause(media::FilterCallback* callback) OVERRIDE;
-  virtual void Stop(media::FilterCallback* callback) OVERRIDE;
+  virtual void Pause(const base::Closure& callback) OVERRIDE;
+  virtual void Stop(const base::Closure& callback) OVERRIDE;
 
   // Decoder implementation.
-  virtual void Initialize(media::DemuxerStream* demuxer_stream,
-                          media::FilterCallback* filter_callback,
-                          media::StatisticsCallback* stat_callback) OVERRIDE;
+  virtual void Initialize(
+      media::DemuxerStream* demuxer_stream,
+      const base::Closure& filter_callback,
+      const media::StatisticsCallback& stat_callback) OVERRIDE;
   virtual void ProduceVideoFrame(
       scoped_refptr<media::VideoFrame> video_frame) OVERRIDE;
   virtual gfx::Size natural_size() OVERRIDE;
diff --git a/content/renderer/media/rtc_video_decoder_unittest.cc b/content/renderer/media/rtc_video_decoder_unittest.cc
index ce434fd..9e0968c 100644
--- a/content/renderer/media/rtc_video_decoder_unittest.cc
+++ b/content/renderer/media/rtc_video_decoder_unittest.cc
@@ -135,9 +135,9 @@ class RTCVideoDecoderTest : public testing::Test {
     message_loop_.RunAllPending();
   }
 
-  StatisticsCallback* NewStatisticsCallback() {
-    return NewCallback(&stats_callback_object_,
-                       &MockStatisticsCallback::OnStatistics);
+  StatisticsCallback NewStatisticsCallback() {
+    return base::Bind(&MockStatisticsCallback::OnStatistics,
+                      base::Unretained(&stats_callback_object_));
   }
 
   // Fixture members.