Add callback in VideoDecoder and AudioDecoder to return decoded frames.

media/filters/ffmpeg_audio_decoder_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <deque>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
@@ skipping 11 matching lines @@
 using ::testing::StrictMock;
 
 namespace media {
 
 class FFmpegAudioDecoderTest : public testing::Test {
  public:
   FFmpegAudioDecoderTest()
       : decoder_(new FFmpegAudioDecoder(message_loop_.message_loop_proxy(),
                                         LogCB())),
         pending_decode_(false),
-        pending_reset_(false) {
+        pending_reset_(false),
+        last_decode_status_(AudioDecoder::kOk) {
     FFmpegGlue::InitializeFFmpeg();
 
     vorbis_extradata_ = ReadTestDataFile("vorbis-extradata");
 
     // Refer to media/test/data/README for details on vorbis test data.
     for (int i = 0; i < 4; ++i) {
       scoped_refptr<DecoderBuffer> buffer =
           ReadTestDataFile(base::StringPrintf("vorbis-packet-%d", i));
 
       if (i < 3) {
@@ skipping 19 matching lines @@
 
   void Initialize() {
     AudioDecoderConfig config(kCodecVorbis,
                               kSampleFormatPlanarF32,
                               CHANNEL_LAYOUT_STEREO,
                               44100,
                               vorbis_extradata_->data(),
                               vorbis_extradata_->data_size(),
                               false);  // Not encrypted.
     decoder_->Initialize(config,
-                         NewExpectedStatusCB(PIPELINE_OK));
+                         NewExpectedStatusCB(PIPELINE_OK),
+                         base::Bind(&FFmpegAudioDecoderTest::OnDecoderOutput,
+                                    base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
   }
 
   void SatisfyPendingDecode() {
     base::RunLoop().RunUntilIdle();
   }
 
-  void Decode() {
+  void Decode(AudioDecoder::Status expected_status) {
     pending_decode_ = true;
     scoped_refptr<DecoderBuffer> buffer(encoded_audio_.front());
     encoded_audio_.pop_front();
     decoder_->Decode(buffer,
                      base::Bind(&FFmpegAudioDecoderTest::DecodeFinished,
                                 base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
+    EXPECT_FALSE(pending_decode_);
+    EXPECT_EQ(expected_status, last_decode_status_);
   }
 
   void Reset() {
     pending_reset_ = true;
     decoder_->Reset(base::Bind(
         &FFmpegAudioDecoderTest::ResetFinished, base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
   }
 
   void Stop() {
     decoder_->Stop();
     base::RunLoop().RunUntilIdle();
   }
 
-  void DecodeFinished(AudioDecoder::Status status,
-                      const scoped_refptr<AudioBuffer>& buffer) {
+  void OnDecoderOutput(const scoped_refptr<AudioBuffer>& buffer) {
+    LOG(ERROR) << "Outp";

[xhwang, 2014/06/05 21:53:50]

rm

[Sergey Ulanov, 2014/06/06 22:49:40]

Done.

+    decoded_audio_.push_back(buffer);
+  }
+
+  void DecodeFinished(AudioDecoder::Status status) {
+    LOG(ERROR) << "Finished";

[xhwang, 2014/06/05 21:53:50]

rm

[Sergey Ulanov, 2014/06/06 22:49:40]

Done.

     EXPECT_TRUE(pending_decode_);
     pending_decode_ = false;
 
-    if (status == AudioDecoder::kNotEnoughData) {
-      EXPECT_TRUE(buffer.get() == NULL);
-      Decode();
-      return;
-    }
-
-    decoded_audio_.push_back(buffer);
-
-    // If we hit a NULL buffer or have a pending reset, we expect an abort.
-    if (buffer.get() == NULL || pending_reset_) {
-      EXPECT_TRUE(buffer.get() == NULL);
-      EXPECT_EQ(status, AudioDecoder::kAborted);
-      return;
-    }
-
-    EXPECT_EQ(status, AudioDecoder::kOk);
+    last_decode_status_ = status;
   }
 
   void ResetFinished() {
     EXPECT_TRUE(pending_reset_);
     // Reset should always finish after Decode.
     EXPECT_FALSE(pending_decode_);
 
     pending_reset_ = false;
   }
 
@@ skipping 11 matching lines @@
 
   base::MessageLoop message_loop_;
   scoped_ptr<FFmpegAudioDecoder> decoder_;
   bool pending_decode_;
   bool pending_reset_;
 
   scoped_refptr<DecoderBuffer> vorbis_extradata_;
 
   std::deque<scoped_refptr<DecoderBuffer> > encoded_audio_;
   std::deque<scoped_refptr<AudioBuffer> > decoded_audio_;
+  AudioDecoder::Status last_decode_status_;
 };
 
 TEST_F(FFmpegAudioDecoderTest, Initialize) {
   AudioDecoderConfig config(kCodecVorbis,
                             kSampleFormatPlanarF32,
                             CHANNEL_LAYOUT_STEREO,
                             44100,
                             vorbis_extradata_->data(),
                             vorbis_extradata_->data_size(),
                             false);  // Not encrypted.
   Stop();
 }
 
 TEST_F(FFmpegAudioDecoderTest, ProduceAudioSamples) {
   // Vorbis requires N+1 packets to produce audio data for N packets.
   //
   // This will should result in the demuxer receiving three reads for two
   // requests to produce audio samples.
-  Decode();
-  Decode();
-  Decode();
+  Decode(AudioDecoder::kOk);
+  Decode(AudioDecoder::kOk);
+  Decode(AudioDecoder::kOk);
+  Decode(AudioDecoder::kOk);
 
   ASSERT_EQ(3u, decoded_audio_.size());
   ExpectDecodedAudio(0, 0, 2902);
   ExpectDecodedAudio(1, 2902, 13061);
   ExpectDecodedAudio(2, 15963, 23219);
 
   // Call one more time to trigger EOS.
-  Decode();
-  ASSERT_EQ(4u, decoded_audio_.size());
+  Decode(AudioDecoder::kOk);
+  ASSERT_EQ(5u, decoded_audio_.size());
   ExpectEndOfStream(3);
   Stop();
 }
 
 TEST_F(FFmpegAudioDecoderTest, DecodeAbort) {
   encoded_audio_.clear();
   encoded_audio_.push_back(NULL);
-  Decode();
-
-  EXPECT_EQ(decoded_audio_.size(), 1u);
-  EXPECT_TRUE(decoded_audio_[0].get() ==  NULL);
+  Decode(AudioDecoder::kAborted);

[xhwang, 2014/06/05 21:53:50]

This is probably obsolete. Now DemuxerStream will never call Decode(NULL). So we
may just remove this test.

If we do that, then all results in this test are kOk. We may just remove
|expected_status| in Decode() call.

[Sergey Ulanov, 2014/06/06 22:49:40]

Done.

+  EXPECT_TRUE(decoded_audio_.empty());
   Stop();
 }
 
 TEST_F(FFmpegAudioDecoderTest, PendingDecode_Stop) {
-  Decode();
+  Decode(AudioDecoder::kOk);
   Stop();
   SatisfyPendingDecode();
 }
 
 TEST_F(FFmpegAudioDecoderTest, PendingDecode_Reset) {
-  Decode();
+  Decode(AudioDecoder::kOk);
   Reset();
   SatisfyPendingDecode();
   Stop();
 }
 
 TEST_F(FFmpegAudioDecoderTest, PendingDecode_ResetStop) {
-  Decode();
+  Decode(AudioDecoder::kOk);
   Reset();
   Stop();
   SatisfyPendingDecode();
 }
 
 }  // namespace media