Add AudioBufferStream.

media/filters/audio_renderer_impl_unittest.cc

Index: media/filters/audio_renderer_impl_unittest.cc
diff --git a/media/filters/audio_renderer_impl_unittest.cc b/media/filters/audio_renderer_impl_unittest.cc
index ef215a0ab94acf7cfe7a8b96a2638e42a8f4b22f..f76da20edac829d19f0647e18d19fd8dc29d9c0e 100644
--- a/media/filters/audio_renderer_impl_unittest.cc
+++ b/media/filters/audio_renderer_impl_unittest.cc
@@ -64,8 +64,8 @@ class AudioRendererImplTest : public ::testing::Test {
     demuxer_stream_.set_audio_decoder_config(audio_config);
 
     // Used to save callbacks and run them at a later time.
-    EXPECT_CALL(*decoder_, Read(_))
-        .WillRepeatedly(Invoke(this, &AudioRendererImplTest::ReadDecoder));
+    EXPECT_CALL(*decoder_, Decode(_, _))
+        .WillRepeatedly(Invoke(this, &AudioRendererImplTest::DecodeDecoder));
 
     EXPECT_CALL(*decoder_, Reset(_))
         .WillRepeatedly(Invoke(this, &AudioRendererImplTest::ResetDecoder));
@@ -81,6 +81,10 @@ class AudioRendererImplTest : public ::testing::Test {
     EXPECT_CALL(*decoder_, samples_per_second())
         .WillRepeatedly(Return(audio_config.samples_per_second()));
 
+    // Mock out demuxer reads
+    EXPECT_CALL(demuxer_stream_, Read(_)).WillRepeatedly(
+        RunCallback<0>(DemuxerStream::kOk, DecoderBuffer::CreateEOSBuffer()));
+
     ScopedVector<AudioDecoder> decoders;
     decoders.push_back(decoder_);
     sink_ = new FakeAudioRendererSink();
@@ -105,7 +109,7 @@ class AudioRendererImplTest : public ::testing::Test {
   }
 
   void ExpectUnsupportedAudioDecoder() {
-    EXPECT_CALL(*decoder_, Initialize(_, _, _))
+    EXPECT_CALL(*decoder_, Initialize(_, _))
         .WillOnce(RunCallback<1>(DECODER_ERROR_NOT_SUPPORTED));
   }
 
@@ -116,7 +120,7 @@ class AudioRendererImplTest : public ::testing::Test {
         .WillRepeatedly(Return(CHANNEL_LAYOUT_UNSUPPORTED));
     EXPECT_CALL(*decoder_, samples_per_second())
         .WillRepeatedly(Return(0));
-    EXPECT_CALL(*decoder_, Initialize(_, _, _))
+    EXPECT_CALL(*decoder_, Initialize(_, _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
   }
 
@@ -130,7 +134,7 @@ class AudioRendererImplTest : public ::testing::Test {
   }
 
   void Initialize() {
-    EXPECT_CALL(*decoder_, Initialize(_, _, _))
+    EXPECT_CALL(*decoder_, Initialize(_, _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
     InitializeWithStatus(PIPELINE_OK);
 
@@ -159,11 +163,11 @@ class AudioRendererImplTest : public ::testing::Test {
     event.RunAndWaitForStatus(expected);
 
     // We should have no reads.
-    EXPECT_TRUE(read_cb_.is_null());
+    EXPECT_TRUE(decode_cb_.is_null());
   }
 
   void InitializeAndStop() {
-    EXPECT_CALL(*decoder_, Initialize(_, _, _))
+    EXPECT_CALL(*decoder_, Initialize(_, _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
     WaitableMessageLoopEvent event;
     renderer_->Initialize(
@@ -189,7 +193,7 @@ class AudioRendererImplTest : public ::testing::Test {
   }
 
   void InitializeAndStopDuringDecoderInit() {
-    EXPECT_CALL(*decoder_, Initialize(_, _, _))
+    EXPECT_CALL(*decoder_, Initialize(_, _))
         .WillOnce(EnterPendingDecoderInitStateAction(this));
     WaitableMessageLoopEvent event;
     renderer_->Initialize(
@@ -247,7 +251,7 @@ class AudioRendererImplTest : public ::testing::Test {
     event.RunAndWaitForStatus(PIPELINE_OK);
 
     // We should have no reads.
-    EXPECT_TRUE(read_cb_.is_null());
+    EXPECT_TRUE(decode_cb_.is_null());
   }
 
   void Play() {
@@ -278,28 +282,28 @@ class AudioRendererImplTest : public ::testing::Test {
   }
 
   bool IsReadPending() const {
-    return !read_cb_.is_null();
+    return !decode_cb_.is_null();
   }
 
   void WaitForPendingRead() {
     SCOPED_TRACE("WaitForPendingRead()");
-    if (!read_cb_.is_null())
+    if (!decode_cb_.is_null())
       return;
 
-    DCHECK(wait_for_pending_read_cb_.is_null());
+    DCHECK(wait_for_pending_decode_cb_.is_null());
 
     WaitableMessageLoopEvent event;
-    wait_for_pending_read_cb_ = event.GetClosure();
+    wait_for_pending_decode_cb_ = event.GetClosure();
     event.RunAndWait();
 
-    DCHECK(!read_cb_.is_null());
-    DCHECK(wait_for_pending_read_cb_.is_null());
+    DCHECK(!decode_cb_.is_null());
+    DCHECK(wait_for_pending_decode_cb_.is_null());
   }
 
   // Delivers |size| frames with value kPlayingAudio to |renderer_|.
   void SatisfyPendingRead(int size) {
     CHECK_GT(size, 0);
-    CHECK(!read_cb_.is_null());
+    CHECK(!decode_cb_.is_null());
 
     scoped_refptr<AudioBuffer> buffer =
         MakeAudioBuffer<float>(kSampleFormat,
@@ -466,28 +470,29 @@ class AudioRendererImplTest : public ::testing::Test {
     return time_;
   }
 
-  void ReadDecoder(const AudioDecoder::ReadCB& read_cb) {
+  void DecodeDecoder(const scoped_refptr<DecoderBuffer>& buffer,
+                     const AudioDecoder::DecodeCB& decode_cb) {
     // We shouldn't ever call Read() after Stop():
     EXPECT_TRUE(stop_decoder_cb_.is_null());
 
     // TODO(scherkus): Make this a DCHECK after threading semantics are fixed.
     if (base::MessageLoop::current() != &message_loop_) {
       message_loop_.PostTask(FROM_HERE, base::Bind(
-          &AudioRendererImplTest::ReadDecoder,
-          base::Unretained(this), read_cb));
+          &AudioRendererImplTest::DecodeDecoder,
+          base::Unretained(this), buffer, decode_cb));
       return;
     }
 
-    CHECK(read_cb_.is_null()) << "Overlapping reads are not permitted";
-    read_cb_ = read_cb;
+    CHECK(decode_cb_.is_null()) << "Overlapping decodes are not permitted";
+    decode_cb_ = decode_cb;
 
     // Wake up WaitForPendingRead() if needed.
-    if (!wait_for_pending_read_cb_.is_null())
-      base::ResetAndReturn(&wait_for_pending_read_cb_).Run();
+    if (!wait_for_pending_decode_cb_.is_null())
+      base::ResetAndReturn(&wait_for_pending_decode_cb_).Run();
   }
 
   void ResetDecoder(const base::Closure& reset_cb) {
-    CHECK(read_cb_.is_null())
+    CHECK(decode_cb_.is_null())
         << "Reset overlapping with reads is not permitted";
 
     message_loop_.PostTask(FROM_HERE, reset_cb);
@@ -503,8 +508,8 @@ class AudioRendererImplTest : public ::testing::Test {
 
   void DeliverBuffer(AudioDecoder::Status status,
                      const scoped_refptr<AudioBuffer>& buffer) {
-    CHECK(!read_cb_.is_null());
-    base::ResetAndReturn(&read_cb_).Run(status, buffer);
+    CHECK(!decode_cb_.is_null());
+    base::ResetAndReturn(&decode_cb_).Run(status, buffer);
   }
 
   MockDemuxerStream demuxer_stream_;
@@ -515,13 +520,13 @@ class AudioRendererImplTest : public ::testing::Test {
   TimeTicks time_;
 
   // Used for satisfying reads.
-  AudioDecoder::ReadCB read_cb_;
+  AudioDecoder::DecodeCB decode_cb_;
   scoped_ptr<AudioTimestampHelper> next_timestamp_;
 
   WaitableMessageLoopEvent ended_event_;
 
-  // Run during ReadDecoder() to unblock WaitForPendingRead().
-  base::Closure wait_for_pending_read_cb_;
+  // Run during DecodeDecoder() to unblock WaitForPendingRead().
+  base::Closure wait_for_pending_decode_cb_;
   base::Closure stop_decoder_cb_;
 
   PipelineStatusCB init_decoder_cb_;