Upstream version 9.37.197.0

[platform/framework/web/crosswalk.git] / src / media / filters / ffmpeg_audio_decoder_unittest.cc

diff --git a/src/media/filters/ffmpeg_audio_decoder_unittest.cc b/src/media/filters/ffmpeg_audio_decoder_unittest.cc
index ee09669..05d1ee2 100644 (file)
--- a/src/media/filters/ffmpeg_audio_decoder_unittest.cc
+++ b/src/media/filters/ffmpeg_audio_decoder_unittest.cc
@@ -26,10 +26,11 @@ namespace media {
 class FFmpegAudioDecoderTest : public testing::Test {
  public:
   FFmpegAudioDecoderTest()
-      : decoder_(new FFmpegAudioDecoder(message_loop_.message_loop_proxy())),
+      : decoder_(new FFmpegAudioDecoder(message_loop_.message_loop_proxy(),
+                                        LogCB())),
         pending_decode_(false),
         pending_reset_(false),
-        pending_stop_(false) {
+        last_decode_status_(AudioDecoder::kOk) {
     FFmpegGlue::InitializeFFmpeg();
 
     vorbis_extradata_ = ReadTestDataFile("vorbis-extradata");
@@ -58,7 +59,6 @@ class FFmpegAudioDecoderTest : public testing::Test {
   virtual ~FFmpegAudioDecoderTest() {
     EXPECT_FALSE(pending_decode_);
     EXPECT_FALSE(pending_reset_);
-    EXPECT_FALSE(pending_stop_);
   }
 
   void Initialize() {
@@ -70,7 +70,9 @@ class FFmpegAudioDecoderTest : public testing::Test {
                               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();
   }
 
@@ -86,6 +88,8 @@ class FFmpegAudioDecoderTest : public testing::Test {
                      base::Bind(&FFmpegAudioDecoderTest::DecodeFinished,
                                 base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
+    EXPECT_FALSE(pending_decode_);
+    EXPECT_EQ(AudioDecoder::kOk, last_decode_status_);
   }
 
   void Reset() {
@@ -96,42 +100,20 @@ class FFmpegAudioDecoderTest : public testing::Test {
   }
 
   void Stop() {
-    pending_stop_ = true;
-    decoder_->Stop(base::Bind(
-        &FFmpegAudioDecoderTest::StopFinished, base::Unretained(this)));
+    decoder_->Stop();
     base::RunLoop().RunUntilIdle();
   }
 
-  void DecodeFinished(AudioDecoder::Status status,
-                      const scoped_refptr<AudioBuffer>& buffer) {
-    EXPECT_TRUE(pending_decode_);
-    pending_decode_ = false;
-
-    if (status == AudioDecoder::kNotEnoughData) {
-      EXPECT_TRUE(buffer.get() == NULL);
-      Decode();
-      return;
-    }
-
+  void OnDecoderOutput(const scoped_refptr<AudioBuffer>& buffer) {
+    EXPECT_FALSE(buffer->end_of_stream());
     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_stop_ || pending_reset_) {
-      EXPECT_TRUE(buffer.get() == NULL);
-      EXPECT_EQ(status, AudioDecoder::kAborted);
-      return;
-    }
-
-    EXPECT_EQ(status, AudioDecoder::kOk);
   }
 
-  void StopFinished() {
-    EXPECT_TRUE(pending_stop_);
-    // Stop should always finish after Decode and Reset.
-    EXPECT_FALSE(pending_decode_);
-    EXPECT_FALSE(pending_reset_);
+  void DecodeFinished(AudioDecoder::Status status) {
+    EXPECT_TRUE(pending_decode_);
+    pending_decode_ = false;
 
-    pending_stop_ = false;
+    last_decode_status_ = status;
   }
 
   void ResetFinished() {
@@ -146,24 +128,18 @@ class FFmpegAudioDecoderTest : public testing::Test {
     EXPECT_LT(i, decoded_audio_.size());
     EXPECT_EQ(timestamp, decoded_audio_[i]->timestamp().InMicroseconds());
     EXPECT_EQ(duration, decoded_audio_[i]->duration().InMicroseconds());
-    EXPECT_FALSE(decoded_audio_[i]->end_of_stream());
-  }
-
-  void ExpectEndOfStream(size_t i) {
-    EXPECT_LT(i, decoded_audio_.size());
-    EXPECT_TRUE(decoded_audio_[i]->end_of_stream());
   }
 
   base::MessageLoop message_loop_;
   scoped_ptr<FFmpegAudioDecoder> decoder_;
   bool pending_decode_;
   bool pending_reset_;
-  bool pending_stop_;
 
   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) {
@@ -185,26 +161,16 @@ TEST_F(FFmpegAudioDecoderTest, ProduceAudioSamples) {
   Decode();
   Decode();
   Decode();
+  Decode();
 
   ASSERT_EQ(3u, decoded_audio_.size());
   ExpectDecodedAudio(0, 0, 2902);
   ExpectDecodedAudio(1, 2902, 13061);
-  ExpectDecodedAudio(2, 15963, 23220);
-
-  // Call one more time to trigger EOS.
-  Decode();
-  ASSERT_EQ(4u, decoded_audio_.size());
-  ExpectEndOfStream(3);
-  Stop();
-}
+  ExpectDecodedAudio(2, 15963, 23219);
 
-TEST_F(FFmpegAudioDecoderTest, DecodeAbort) {
-  encoded_audio_.clear();
-  encoded_audio_.push_back(NULL);
+  // Call one more time with EOS.
   Decode();
-
-  EXPECT_EQ(decoded_audio_.size(), 1u);
-  EXPECT_TRUE(decoded_audio_[0].get() ==  NULL);
+  ASSERT_EQ(3u, decoded_audio_.size());
   Stop();
 }
 
@@ -212,7 +178,6 @@ TEST_F(FFmpegAudioDecoderTest, PendingDecode_Stop) {
   Decode();
   Stop();
   SatisfyPendingDecode();
-  Stop();
 }
 
 TEST_F(FFmpegAudioDecoderTest, PendingDecode_Reset) {