Switch AudioDecoder's ConsumeAudioSamplesCallback over to the new hotness callbacks.

They are indeed hot.

BUG=none
TEST=media_unittests, unit_tests, etc...

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

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

9 files changed, 50 insertions, 69 deletions

diff --git a/media/base/filters.cc b/media/base/filters.cc
index 1386842..8b2e24a 100644
--- a/media/base/filters.cc
+++ b/media/base/filters.cc
@@ -80,4 +80,8 @@ AudioDecoder::AudioDecoder() {}
 
 AudioDecoder::~AudioDecoder() {}
 
+void AudioDecoder::ConsumeAudioSamples(scoped_refptr<Buffer> buffer) {
+  consume_audio_samples_callback_.Run(buffer);
+}
+
 }  // namespace media
diff --git a/media/base/filters.h b/media/base/filters.h
index f290fec..36d7017 100644
--- a/media/base/filters.h
+++ b/media/base/filters.h
@@ -241,29 +241,27 @@ class AudioDecoder : public Filter {
 
   virtual AudioDecoderConfig config() = 0;
 
-  // |set_fill_buffer_done_callback| install permanent callback from downstream
-  // filter (i.e. Renderer). The callback is used to deliver buffers at
-  // runtime to downstream filter.
-  typedef Callback1<scoped_refptr<Buffer> >::Type ConsumeAudioSamplesCallback;
-  void set_consume_audio_samples_callback(
-      ConsumeAudioSamplesCallback* callback) {
-    consume_audio_samples_callback_.reset(callback);
-  }
-  ConsumeAudioSamplesCallback* consume_audio_samples_callback() {
-     return consume_audio_samples_callback_.get();
-   }
-
   // Renderer provides an output buffer for Decoder to write to. These buffers
   // will be recycled to renderer by fill_buffer_done_callback_;
   // We could also pass empty pointer here to let decoder provide buffers pool.
   virtual void ProduceAudioSamples(scoped_refptr<Buffer> buffer) = 0;
 
+  // Installs a permanent callback for passing decoded audio output.
+  typedef base::Callback<void(scoped_refptr<Buffer>)> ConsumeAudioSamplesCB;
+  void set_consume_audio_samples_callback(
+      const ConsumeAudioSamplesCB& callback) {
+    consume_audio_samples_callback_ = callback;
+  }
+
  protected:
   AudioDecoder();
   ~AudioDecoder();
 
+  // Executes the permanent callback to pass off decoded audio.
+  void ConsumeAudioSamples(scoped_refptr<Buffer> buffer);
+
  private:
-  scoped_ptr<ConsumeAudioSamplesCallback> consume_audio_samples_callback_;
+  ConsumeAudioSamplesCB consume_audio_samples_callback_;
 };
 
 
diff --git a/media/base/mock_filters.h b/media/base/mock_filters.h
index 7a58095..edc3b26 100644
--- a/media/base/mock_filters.h
+++ b/media/base/mock_filters.h
@@ -217,9 +217,8 @@ class MockAudioDecoder : public AudioDecoder {
   MOCK_METHOD0(config, AudioDecoderConfig());
   MOCK_METHOD1(ProduceAudioSamples, void(scoped_refptr<Buffer>));
 
-  // change to public to allow unittest for access;
-  ConsumeAudioSamplesCallback* consume_audio_samples_callback() {
-    return AudioDecoder::consume_audio_samples_callback();
+  void ConsumeAudioSamplesForTest(scoped_refptr<Buffer> buffer) {
+    AudioDecoder::ConsumeAudioSamples(buffer);
   }
 
  protected:
diff --git a/media/filters/audio_renderer_base.cc b/media/filters/audio_renderer_base.cc
index 7e40ba1..45dd699 100644
--- a/media/filters/audio_renderer_base.cc
+++ b/media/filters/audio_renderer_base.cc
@@ -7,6 +7,7 @@
 #include <algorithm>
 #include <string>
 
+#include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "media/base/filter_host.h"
@@ -88,8 +89,10 @@ void AudioRendererBase::Initialize(AudioDecoder* decoder,
   scoped_ptr<FilterCallback> c(callback);
   decoder_ = decoder;
 
+  // Use base::Unretained() as the decoder doesn't need to ref us.
   decoder_->set_consume_audio_samples_callback(
-      NewCallback(this, &AudioRendererBase::ConsumeAudioSamples));
+      base::Bind(&AudioRendererBase::ConsumeAudioSamples,
+                 base::Unretained(this)));
 
   // Create a callback so our algorithm can request more reads.
   AudioRendererAlgorithmBase::RequestReadCallback* cb =
diff --git a/media/filters/audio_renderer_base_unittest.cc b/media/filters/audio_renderer_base_unittest.cc
index f63bad9..9385f53f 100644
--- a/media/filters/audio_renderer_base_unittest.cc
+++ b/media/filters/audio_renderer_base_unittest.cc
@@ -127,7 +127,7 @@ TEST_F(AudioRendererBaseTest, Initialize_Successful) {
     scoped_refptr<DataBuffer> buffer(new DataBuffer(1024));
     buffer->SetDataSize(1024);
     --pending_reads_;
-    decoder_->consume_audio_samples_callback()->Run(buffer);
+    decoder_->ConsumeAudioSamplesForTest(buffer);
   }
 }
 
@@ -156,7 +156,7 @@ TEST_F(AudioRendererBaseTest, OneCompleteReadCycle) {
   while (pending_reads_) {
     scoped_refptr<DataBuffer> buffer(new DataBuffer(kDataSize));
     buffer->SetDataSize(kDataSize);
-    decoder_->consume_audio_samples_callback()->Run(buffer);
+    decoder_->ConsumeAudioSamplesForTest(buffer);
     --pending_reads_;
     bytes_buffered += kDataSize;
   }
@@ -180,7 +180,7 @@ TEST_F(AudioRendererBaseTest, OneCompleteReadCycle) {
 
   // Fulfill the read with an end-of-stream packet.
   scoped_refptr<DataBuffer> last_buffer(new DataBuffer(0));
-  decoder_->consume_audio_samples_callback()->Run(last_buffer);
+  decoder_->ConsumeAudioSamplesForTest(last_buffer);
   --pending_reads_;
 
   // We shouldn't report ended until all data has been flushed out.
diff --git a/media/filters/decoder_base.h b/media/filters/decoder_base.h
index 280c0bf..6b027f6 100644
--- a/media/filters/decoder_base.h
+++ b/media/filters/decoder_base.h
@@ -53,10 +53,9 @@ class DecoderBase : public Decoder {
                           callback));
   }
 
-  // Audio decoder.
-  // Note that this class is only used by the audio decoder, this will
-  // eventually be merged into FFmpegAudioDecoder.
-  virtual void ProduceAudioSamples(scoped_refptr<Output> output) {
+  // TODO(scherkus): Since FFmpegAudioDecoder is the only subclass this is a
+  // temporary hack until I finish removing DecoderBase.
+  void PostReadTaskHack(scoped_refptr<Output> output) {
     message_loop_->PostTask(FROM_HERE,
         NewRunnableMethod(this, &DecoderBase::ReadTask, output));
   }
@@ -268,10 +267,9 @@ class DecoderBase : public Decoder {
     // Execute the callback!
     --pending_requests_;
 
-    // TODO(hclam): We only inherit this class from FFmpegAudioDecoder so we
-    // are making this call. We should correct this by merging this class into
-    // FFmpegAudioDecoder.
-    Decoder::consume_audio_samples_callback()->Run(output);
+    // TODO(scherkus): Since FFmpegAudioDecoder is the only subclass this is a
+    // temporary hack until I finish removing DecoderBase.
+    Decoder::ConsumeAudioSamples(output);
     return true;
   }
 
diff --git a/media/filters/decoder_base_unittest.cc b/media/filters/decoder_base_unittest.cc
index 296bd13c7..efeda8c 100644
--- a/media/filters/decoder_base_unittest.cc
+++ b/media/filters/decoder_base_unittest.cc
@@ -4,6 +4,8 @@
 
 #include <vector>
 
+#include "base/bind.h"
+#include "media/base/data_buffer.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_filters.h"
 #include "media/base/mock_task.h"
@@ -22,51 +24,20 @@ namespace media {
 
 class GTEST_TEST_CLASS_NAME_(DecoderBaseTest, FlowControl);
 
-class MockDecoderOutput : public StreamSample {
- public:
-  MOCK_CONST_METHOD0(IsEndOfStream, bool());
-};
-
-class MockBuffer : public Buffer {
- public:
-  MockBuffer() {}
-  virtual ~MockBuffer() {}
-  MOCK_CONST_METHOD0(GetData, const uint8*());
-  MOCK_CONST_METHOD0(GetDataSize, size_t());
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockBuffer);
-};
-
-class MockDecoder : public Filter {
- public:
-  typedef Callback1<scoped_refptr<MockDecoderOutput> >::Type
-      ConsumeAudioSamplesCallback;
-  void set_consume_audio_samples_callback(
-      ConsumeAudioSamplesCallback* callback) {
-    consume_audio_samples_callback_.reset(callback);
-  }
-  ConsumeAudioSamplesCallback* consume_audio_samples_callback() {
-    return consume_audio_samples_callback_.get();
-  }
-  scoped_ptr<ConsumeAudioSamplesCallback> consume_audio_samples_callback_;
-};
-
 class MockDecoderCallback {
  public:
-  MOCK_METHOD1(OnReadComplete, void(scoped_refptr<MockDecoderOutput> output));
+  MOCK_METHOD1(OnReadComplete, void(scoped_refptr<Buffer> output));
 };
 
-class MockDecoderImpl : public DecoderBase<
-  MockDecoder, MockDecoderOutput> {
+class MockDecoderImpl : public DecoderBase<MockAudioDecoder, Buffer> {
  public:
   explicit MockDecoderImpl(MessageLoop* message_loop)
-      : DecoderBase<MockDecoder, MockDecoderOutput>(message_loop) {
+      : DecoderBase<MockAudioDecoder, Buffer>(message_loop) {
   }
 
   virtual ~MockDecoderImpl() {}
 
-  // DecoderBase Implementations.
+  // DecoderBase implementation.
   MOCK_METHOD3(DoInitialize,
                void(DemuxerStream* demuxer_stream,
                     bool* success,
@@ -92,7 +63,7 @@ ACTION_P(SaveDecodeRequest, list) {
 }
 
 ACTION(CompleteDemuxRequest) {
-  arg0->Run(new MockBuffer());
+  arg0->Run(new DataBuffer(0));
   delete arg0;
 }
 
@@ -112,9 +83,12 @@ ACTION(CompleteDemuxRequest) {
 TEST(DecoderBaseTest, FlowControl) {
   MessageLoop message_loop;
   scoped_refptr<MockDecoderImpl> decoder(new MockDecoderImpl(&message_loop));
+
   MockDecoderCallback read_callback;
   decoder->set_consume_audio_samples_callback(
-      NewCallback(&read_callback, &MockDecoderCallback::OnReadComplete));
+      base::Bind(&MockDecoderCallback::OnReadComplete,
+                 base::Unretained(&read_callback)));
+
   scoped_refptr<MockDemuxerStream> demuxer_stream(new MockDemuxerStream());
   MockStatisticsCallback stats_callback_object;
   EXPECT_CALL(stats_callback_object, OnStatistics(_))
@@ -136,16 +110,16 @@ TEST(DecoderBaseTest, FlowControl) {
   EXPECT_CALL(*decoder, DoDecode(NotNull()))
       .Times(2)
       .WillRepeatedly(SaveDecodeRequest(&decode_requests));
-  scoped_refptr<MockDecoderOutput> output;
-  decoder->ProduceAudioSamples(output);
-  decoder->ProduceAudioSamples(output);
+  scoped_refptr<DataBuffer> output;
+  decoder->PostReadTaskHack(output);
+  decoder->PostReadTaskHack(output);
   message_loop.RunAllPending();
 
   // Fulfill the decode request.
   EXPECT_CALL(read_callback, OnReadComplete(_)).Times(2);
   PipelineStatistics statistics;
   for (size_t i = 0; i < decode_requests.size(); ++i) {
-    decoder->EnqueueResult(new MockDecoderOutput());
+    decoder->EnqueueResult(new DataBuffer(0));
     decoder->OnDecodeComplete(statistics);
   }
   decode_requests.clear();
diff --git a/media/filters/ffmpeg_audio_decoder.cc b/media/filters/ffmpeg_audio_decoder.cc
index 0dfc783d..807f1d1 100644
--- a/media/filters/ffmpeg_audio_decoder.cc
+++ b/media/filters/ffmpeg_audio_decoder.cc
@@ -87,6 +87,10 @@ AudioDecoderConfig FFmpegAudioDecoder::config() {
   return config_;
 }
 
+void FFmpegAudioDecoder::ProduceAudioSamples(scoped_refptr<Buffer> output) {
+  DecoderBase<AudioDecoder, Buffer>::PostReadTaskHack(output);
+}
+
 void FFmpegAudioDecoder::DoSeek(base::TimeDelta time, Task* done_cb) {
   avcodec_flush_buffers(codec_context_);
   estimated_next_timestamp_ = kNoTimestamp;
diff --git a/media/filters/ffmpeg_audio_decoder.h b/media/filters/ffmpeg_audio_decoder.h
index c3ca801..72978bc 100644
--- a/media/filters/ffmpeg_audio_decoder.h
+++ b/media/filters/ffmpeg_audio_decoder.h
@@ -21,6 +21,7 @@ class FFmpegAudioDecoder : public DecoderBase<AudioDecoder, Buffer> {
 
   // AudioDecoder implementation.
   virtual AudioDecoderConfig config();
+  virtual void ProduceAudioSamples(scoped_refptr<Buffer> output);
 
  protected:
   virtual void DoInitialize(DemuxerStream* demuxer_stream, bool* success,