Convert Demuxer::Read() to use the new callback system.

BUG=82167
TEST=Existing unit tests still pass.

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

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

14 files changed, 41 insertions, 46 deletions

diff --git a/content/renderer/media/ipc_video_decoder.cc b/content/renderer/media/ipc_video_decoder.cc
index 7c59c8b..37f7983 100644
--- a/content/renderer/media/ipc_video_decoder.cc
+++ b/content/renderer/media/ipc_video_decoder.cc
@@ -199,5 +199,5 @@ void IpcVideoDecoder::ConsumeVideoFrame(
 // This method is called by VideoDecodeEngine to request a video frame. The
 // request is passed to demuxer.
 void IpcVideoDecoder::ProduceVideoSample(scoped_refptr<media::Buffer> buffer) {
-  demuxer_stream_->Read(NewCallback(this, &IpcVideoDecoder::OnReadComplete));
+  demuxer_stream_->Read(base::Bind(&IpcVideoDecoder::OnReadComplete, this));
 }
diff --git a/media/base/filters.h b/media/base/filters.h
index f569e73..901a91b 100644
--- a/media/base/filters.h
+++ b/media/base/filters.h
@@ -151,6 +151,8 @@ class DataSource : public Filter {
 
 class DemuxerStream : public base::RefCountedThreadSafe<DemuxerStream> {
  public:
+  typedef base::Callback<void(Buffer*)> ReadCallback;
+
   enum Type {
     UNKNOWN,
     AUDIO,
@@ -160,9 +162,7 @@ class DemuxerStream : public base::RefCountedThreadSafe<DemuxerStream> {
 
   // Schedules a read.  When the |read_callback| is called, the downstream
   // filter takes ownership of the buffer by AddRef()'ing the buffer.
-  //
-  // TODO(scherkus): switch Read() callback to scoped_refptr<>.
-  virtual void Read(Callback1<Buffer*>::Type* read_callback) = 0;
+  virtual void Read(const ReadCallback& read_callback) = 0;
 
   // Returns an |AVStream*| if supported, or NULL.
   virtual AVStream* GetAVStream();
diff --git a/media/base/mock_filters.h b/media/base/mock_filters.h
index bf66b0c..1564437 100644
--- a/media/base/mock_filters.h
+++ b/media/base/mock_filters.h
@@ -157,7 +157,7 @@ class MockDemuxerStream : public DemuxerStream {
   // DemuxerStream implementation.
   MOCK_METHOD0(type, Type());
   MOCK_METHOD0(media_format, const MediaFormat&());
-  MOCK_METHOD1(Read, void(Callback1<Buffer*>::Type* read_callback));
+  MOCK_METHOD1(Read, void(const ReadCallback& read_callback));
   MOCK_METHOD0(GetAVStream, AVStream*());
   MOCK_METHOD0(EnableBitstreamConverter, void());
 
diff --git a/media/base/mock_reader.h b/media/base/mock_reader.h
index 8036658..35b374e 100644
--- a/media/base/mock_reader.h
+++ b/media/base/mock_reader.h
@@ -7,6 +7,7 @@
 
 #include <string>
 
+#include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "media/base/filters.h"
@@ -40,7 +41,7 @@ class MockReader :
     DCHECK(!expecting_call_);
     called_ = false;
     expecting_call_ = true;
-    filter->Read(NewCallback(this, &MockReader::OnReadComplete));
+    filter->Read(base::Bind(&MockReader::OnReadComplete, this));
   }
 
   // Mock accessors.
@@ -71,8 +72,6 @@ class MockReader :
 
 // Commonly used reader types.
 typedef MockReader<DemuxerStream, Buffer> DemuxerStreamReader;
-typedef MockReader<AudioDecoder, Buffer> AudioDecoderReader;
-typedef MockReader<VideoDecoder, VideoFrame> VideoDecoderReader;
 
 }  // namespace media
 
diff --git a/media/filters/adaptive_demuxer.cc b/media/filters/adaptive_demuxer.cc
index 7fe2ab7..9a94d11 100644
--- a/media/filters/adaptive_demuxer.cc
+++ b/media/filters/adaptive_demuxer.cc
@@ -55,7 +55,7 @@ DemuxerStream* AdaptiveDemuxerStream::current_stream() {
   return streams_[current_stream_index_];
 }
 
-void AdaptiveDemuxerStream::Read(Callback1<Buffer*>::Type* read_callback) {
+void AdaptiveDemuxerStream::Read(const ReadCallback& read_callback) {
   current_stream()->Read(read_callback);
 }
 
diff --git a/media/filters/adaptive_demuxer.h b/media/filters/adaptive_demuxer.h
index c38b4e7..b4836bb 100644
--- a/media/filters/adaptive_demuxer.h
+++ b/media/filters/adaptive_demuxer.h
@@ -40,7 +40,7 @@ class AdaptiveDemuxerStream : public DemuxerStream {
   void ChangeCurrentStream(int index);
 
   // DemuxerStream methods.
-  virtual void Read(Callback1<Buffer*>::Type* read_callback);
+  virtual void Read(const ReadCallback& read_callback);
   virtual Type type();
   virtual const MediaFormat& media_format();
   virtual void EnableBitstreamConverter();
diff --git a/media/filters/decoder_base.h b/media/filters/decoder_base.h
index 6b027f6..6cf4937 100644
--- a/media/filters/decoder_base.h
+++ b/media/filters/decoder_base.h
@@ -9,6 +9,7 @@
 
 #include <deque>
 
+#include "base/bind.h"
 #include "base/callback.h"
 #include "base/stl_util-inl.h"
 #include "base/task.h"
@@ -129,8 +130,8 @@ class DecoderBase : public Decoder {
     DCHECK_LE(pending_reads_, pending_requests_);
     if (!fulfilled) {
       DCHECK_LT(pending_reads_, pending_requests_);
-      demuxer_stream_->Read(NewCallback(this, &DecoderBase::OnReadComplete));
       ++pending_reads_;
+      demuxer_stream_->Read(base::Bind(&DecoderBase::OnReadComplete, this));
     }
   }
 
@@ -234,8 +235,8 @@ class DecoderBase : public Decoder {
 
     // Since we can't fulfill a read request now then submit a read
     // request to the demuxer stream.
-    demuxer_stream_->Read(NewCallback(this, &DecoderBase::OnReadComplete));
     ++pending_reads_;
+    demuxer_stream_->Read(base::Bind(&DecoderBase::OnReadComplete, this));
   }
 
   void ReadCompleteTask(scoped_refptr<Buffer> buffer) {
diff --git a/media/filters/decoder_base_unittest.cc b/media/filters/decoder_base_unittest.cc
index efeda8c..f29bd3a 100644
--- a/media/filters/decoder_base_unittest.cc
+++ b/media/filters/decoder_base_unittest.cc
@@ -63,8 +63,7 @@ ACTION_P(SaveDecodeRequest, list) {
 }
 
 ACTION(CompleteDemuxRequest) {
-  arg0->Run(new DataBuffer(0));
-  delete arg0;
+  arg0.Run(new DataBuffer(0));
 }
 
 // Test the flow control of decoder base by the following sequence of actions:
@@ -104,7 +103,7 @@ TEST(DecoderBaseTest, FlowControl) {
 
   // Read.
   std::vector<scoped_refptr<Buffer> > decode_requests;
-  EXPECT_CALL(*demuxer_stream, Read(NotNull()))
+  EXPECT_CALL(*demuxer_stream, Read(_))
       .Times(2)
       .WillRepeatedly(CompleteDemuxRequest());
   EXPECT_CALL(*decoder, DoDecode(NotNull()))
diff --git a/media/filters/ffmpeg_demuxer.cc b/media/filters/ffmpeg_demuxer.cc
index 9387668..98ec882 100644
--- a/media/filters/ffmpeg_demuxer.cc
+++ b/media/filters/ffmpeg_demuxer.cc
@@ -136,7 +136,7 @@ void FFmpegDemuxerStream::Stop() {
   DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
   base::AutoLock auto_lock(lock_);
   buffer_queue_.clear();
-  STLDeleteElements(&read_queue_);
+  read_queue_.clear();
   stopped_ = true;
 }
 
@@ -152,19 +152,17 @@ const MediaFormat& FFmpegDemuxerStream::media_format() {
   return media_format_;
 }
 
-void FFmpegDemuxerStream::Read(Callback1<Buffer*>::Type* read_callback) {
-  DCHECK(read_callback);
+void FFmpegDemuxerStream::Read(const ReadCallback& read_callback) {
+  DCHECK(!read_callback.is_null());
 
   base::AutoLock auto_lock(lock_);
   if (!buffer_queue_.empty()) {
-    scoped_ptr<Callback1<Buffer*>::Type> read_callback_deleter(read_callback);
-
     // Dequeue a buffer send back.
     scoped_refptr<Buffer> buffer = buffer_queue_.front();
     buffer_queue_.pop_front();
 
     // Execute the callback.
-    read_callback_deleter->Run(buffer);
+    read_callback.Run(buffer);
 
     if (!read_queue_.empty())
       demuxer_->PostDemuxTask();
@@ -175,7 +173,7 @@ void FFmpegDemuxerStream::Read(Callback1<Buffer*>::Type* read_callback) {
   }
 }
 
-void FFmpegDemuxerStream::ReadTask(Callback1<Buffer*>::Type* read_callback) {
+void FFmpegDemuxerStream::ReadTask(const ReadCallback& read_callback) {
   DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
 
   base::AutoLock auto_lock(lock_);
@@ -183,7 +181,6 @@ void FFmpegDemuxerStream::ReadTask(Callback1<Buffer*>::Type* read_callback) {
   //
   // TODO(scherkus): it would be cleaner if we replied with an error message.
   if (stopped_) {
-    delete read_callback;
     return;
   }
 
@@ -206,12 +203,12 @@ void FFmpegDemuxerStream::FulfillPendingRead() {
 
   // Dequeue a buffer and pending read pair.
   scoped_refptr<Buffer> buffer = buffer_queue_.front();
-  scoped_ptr<Callback1<Buffer*>::Type> read_callback(read_queue_.front());
+  ReadCallback read_callback(read_queue_.front());
   buffer_queue_.pop_front();
   read_queue_.pop_front();
 
   // Execute the callback.
-  read_callback->Run(buffer);
+  read_callback.Run(buffer);
 }
 
 void FFmpegDemuxerStream::EnableBitstreamConverter() {
diff --git a/media/filters/ffmpeg_demuxer.h b/media/filters/ffmpeg_demuxer.h
index 674abca..3fe2cf1 100644
--- a/media/filters/ffmpeg_demuxer.h
+++ b/media/filters/ffmpeg_demuxer.h
@@ -81,7 +81,7 @@ class FFmpegDemuxerStream : public DemuxerStream {
   // not make calls into FFmpegDemuxerStream directly or that may cause a
   // deadlock. |read_callback| should execute as quickly as possible because
   // |lock_| is held throughout the life of the callback.
-  virtual void Read(Callback1<Buffer*>::Type* read_callback);
+  virtual void Read(const ReadCallback& read_callback);
   // Bitstream converter to convert input packet.
   virtual void EnableBitstreamConverter();
   virtual AVStream* GetAVStream();
@@ -90,7 +90,7 @@ class FFmpegDemuxerStream : public DemuxerStream {
   virtual ~FFmpegDemuxerStream();
 
   // Carries out enqueuing a pending read on the demuxer thread.
-  void ReadTask(Callback1<Buffer*>::Type* read_callback);
+  void ReadTask(const ReadCallback& read_callback);
 
   // Attempts to fulfill a single pending read by dequeueing a buffer and read
   // callback pair and executing the callback. The calling function must
@@ -112,7 +112,7 @@ class FFmpegDemuxerStream : public DemuxerStream {
   typedef std::deque<scoped_refptr<Buffer> > BufferQueue;
   BufferQueue buffer_queue_;
 
-  typedef std::deque<Callback1<Buffer*>::Type*> ReadQueue;
+  typedef std::deque<ReadCallback> ReadQueue;
   ReadQueue read_queue_;
 
   // Used to translate bitstream formats.
diff --git a/media/filters/ffmpeg_demuxer_unittest.cc b/media/filters/ffmpeg_demuxer_unittest.cc
index 3675f6e..e13fbb1 100644
--- a/media/filters/ffmpeg_demuxer_unittest.cc
+++ b/media/filters/ffmpeg_demuxer_unittest.cc
@@ -519,21 +519,19 @@ TEST_F(FFmpegDemuxerTest, Seek) {
 
 // A mocked callback specialization for calling Read().  Since RunWithParams()
 // is mocked we don't need to pass in object or method pointers.
-typedef CallbackImpl<FFmpegDemuxerTest,
-                     void (FFmpegDemuxerTest::*)(Buffer*),
-                     Tuple1<Buffer*> > ReadCallback;
-class MockReadCallback : public ReadCallback {
+class MockReadCallback : public base::RefCountedThreadSafe<MockReadCallback> {
  public:
-  MockReadCallback()
-      : ReadCallback(NULL, NULL) {
-  }
+  MockReadCallback() {}
 
   virtual ~MockReadCallback() {
     OnDelete();
   }
 
   MOCK_METHOD0(OnDelete, void());
-  MOCK_METHOD1(RunWithParams, void(const Tuple1<Buffer*>& params));
+  MOCK_METHOD1(Run, void(Buffer* buffer));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockReadCallback);
 };
 
 TEST_F(FFmpegDemuxerTest, Stop) {
@@ -544,11 +542,6 @@ TEST_F(FFmpegDemuxerTest, Stop) {
     InitializeDemuxer();
   }
 
-  // Create our mocked callback.  The demuxer will take ownership of this
-  // pointer.
-  scoped_ptr<StrictMock<MockReadCallback> > callback(
-      new StrictMock<MockReadCallback>());
-
   // Get our stream.
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
@@ -564,13 +557,18 @@ TEST_F(FFmpegDemuxerTest, Stop) {
   // Expect all calls in sequence.
   InSequence s;
 
+  // Create our mocked callback. The Callback created by base::Bind() will take
+  // ownership of this pointer.
+  StrictMock<MockReadCallback>* callback = new StrictMock<MockReadCallback>();
+
   // The callback should be immediately deleted.  We'll use a checkpoint to
   // verify that it has indeed been deleted.
   EXPECT_CALL(*callback, OnDelete());
   EXPECT_CALL(mock_ffmpeg_, CheckPoint(1));
 
   // Attempt the read...
-  audio->Read(callback.release());
+  audio->Read(base::Bind(&MockReadCallback::Run, callback));
+
   message_loop_.RunAllPending();
 
   // ...and verify that |callback| was deleted.
diff --git a/media/filters/ffmpeg_video_decoder.cc b/media/filters/ffmpeg_video_decoder.cc
index 2120022..b281fb4 100644
--- a/media/filters/ffmpeg_video_decoder.cc
+++ b/media/filters/ffmpeg_video_decoder.cc
@@ -6,6 +6,7 @@
 
 #include <deque>
 
+#include "base/bind.h"
 #include "base/task.h"
 #include "media/base/callback.h"
 #include "media/base/filters.h"
@@ -348,8 +349,8 @@ void FFmpegVideoDecoder::ProduceVideoSample(
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK_NE(state_, kStopped);
 
-  demuxer_stream_->Read(
-      NewCallback(this, &FFmpegVideoDecoder::OnReadComplete));
+  demuxer_stream_->Read(base::Bind(&FFmpegVideoDecoder::OnReadComplete,
+                                   this));
 }
 
 bool FFmpegVideoDecoder::ProvidesBuffer() {
diff --git a/media/filters/ffmpeg_video_decoder_unittest.cc b/media/filters/ffmpeg_video_decoder_unittest.cc
index 54fb1be..45869f4 100644
--- a/media/filters/ffmpeg_video_decoder_unittest.cc
+++ b/media/filters/ffmpeg_video_decoder_unittest.cc
@@ -284,7 +284,6 @@ ACTION_P2(ReadFromDemux, decoder, buffer) {
 }
 
 ACTION_P3(ReturnFromDemux, decoder, buffer, time_tuple) {
-  delete arg0;
   buffer->SetTimestamp(time_tuple.timestamp);
   buffer->SetDuration(time_tuple.duration);
   decoder->OnReadComplete(buffer);
diff --git a/media/filters/omx_video_decoder.cc b/media/filters/omx_video_decoder.cc
index 43034c6d..43f8100 100644
--- a/media/filters/omx_video_decoder.cc
+++ b/media/filters/omx_video_decoder.cc
@@ -4,6 +4,7 @@
 
 #include "media/filters/omx_video_decoder.h"
 
+#include "base/bind.h"
 #include "base/callback.h"
 #include "base/message_loop.h"
 #include "media/base/callback.h"
@@ -192,7 +193,7 @@ void OmxVideoDecoder::ProduceVideoSample(scoped_refptr<Buffer> buffer) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   // Issue more demux.
-  demuxer_stream_->Read(NewCallback(this, &OmxVideoDecoder::DemuxCompleteTask));
+  demuxer_stream_->Read(base::Bind(&OmxVideoDecoder::DemuxCompleteTask, this));
 }
 
 void OmxVideoDecoder::ConsumeVideoFrame(scoped_refptr<VideoFrame> frame,