Rewriting FFmpegAudioDecoder and eliminating DecoderBase.

media/filters/ffmpeg_audio_decoder_unittest.cc

Index: media/filters/ffmpeg_audio_decoder_unittest.cc
diff --git a/media/filters/ffmpeg_audio_decoder_unittest.cc b/media/filters/ffmpeg_audio_decoder_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a80ec4cf5f49510470bd0d4b5bee9b5f3b367214
--- /dev/null
+++ b/media/filters/ffmpeg_audio_decoder_unittest.cc
@@ -0,0 +1,143 @@
+// Copyright (c) 2011 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 "base/bind.h"
+#include "base/file_path.h"
+#include "base/message_loop.h"
+#include "media/base/mock_callback.h"
+#include "media/base/mock_filters.h"
+#include "media/base/test_data_util.h"
+#include "media/ffmpeg/ffmpeg_common.h"
+#include "media/filters/ffmpeg_audio_decoder.h"
+#include "media/filters/ffmpeg_glue.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using ::testing::_;
+using ::testing::Return;
+
+namespace media {
+
+ACTION_P(InvokeReadPacket, test) {
+  test->ReadPacket(arg0);
+}
+
+class FFmpegAudioDecoderTest : public testing::Test {
+ public:
+  FFmpegAudioDecoderTest()
+      : decoder_(new FFmpegAudioDecoder(&message_loop_)),
+        demuxer_(new MockDemuxerStream()),
+        vorbis_packet_index_(0) {
+    CHECK(FFmpegGlue::GetInstance());
+
+    ReadTestDataFile("vorbis-extradata",
+                     &vorbis_extradata_,
+                     &vorbis_extradata_size_);
+
+    ReadTestDataFile("vorbis-packet-0", &vorbis_packet_0_);
+    ReadTestDataFile("vorbis-packet-1", &vorbis_packet_1_);
+    ReadTestDataFile("vorbis-packet-2", &vorbis_packet_2_);
+
+    decoder_->set_consume_audio_samples_callback(
+        base::Bind(&FFmpegAudioDecoderTest::DecodeFinished,
+                   base::Unretained(this)));
+
+    memset(&stream_, 0, sizeof(stream_));
+    memset(&codec_context_, 0, sizeof(codec_context_));
+
+    stream_.codec = &codec_context_;
+    codec_context_.codec_id = CODEC_ID_VORBIS;
+    codec_context_.codec_type = AVMEDIA_TYPE_AUDIO;
+    codec_context_.channels = 2;
+    codec_context_.channel_layout = AV_CH_LAYOUT_STEREO;
+    codec_context_.sample_fmt = AV_SAMPLE_FMT_S16;
+    codec_context_.sample_rate = 44100;
+    codec_context_.extradata = vorbis_extradata_.get();
+    codec_context_.extradata_size = vorbis_extradata_size_;
+  }
+
+  virtual ~FFmpegAudioDecoderTest() {}
+
+  void Initialize() {
+    EXPECT_CALL(*demuxer_, GetAVStream())
+        .WillOnce(Return(&stream_));
+
+    decoder_->Initialize(demuxer_,
+                         NewExpectedCallback(),
+                         NewCallback(&statistics_callback_,
+                                     &MockStatisticsCallback::OnStatistics));
+
+    message_loop_.RunAllPending();
+  }
+
+  void ReadPacket(const DemuxerStream::ReadCallback& read_callback) {
+    CHECK_LT(vorbis_packet_index_, 3) << "ReadPacket() called too many times";
+    switch (vorbis_packet_index_) {

[acolwell GONE FROM CHROMIUM, 2011/09/13 22:09:28]

Why not use an array or list?

+      case 0:
+        read_callback.Run(vorbis_packet_0_);
+        break;
+      case 1:
+        read_callback.Run(vorbis_packet_1_);
+        break;
+      case 2:
+        read_callback.Run(vorbis_packet_2_);
+        break;
+    }
+    vorbis_packet_index_++;
+  }
+
+  MOCK_METHOD1(DecodeFinished, void(scoped_refptr<Buffer>));
+
+  MessageLoop message_loop_;
+  scoped_refptr<FFmpegAudioDecoder> decoder_;
+  scoped_refptr<MockDemuxerStream> demuxer_;
+  MockStatisticsCallback statistics_callback_;
+
+  scoped_array<uint8> vorbis_extradata_;
+  int vorbis_extradata_size_;
+
+  scoped_refptr<Buffer> vorbis_packet_0_;
+  scoped_refptr<Buffer> vorbis_packet_1_;
+  scoped_refptr<Buffer> vorbis_packet_2_;
+  int vorbis_packet_index_;
+
+  AVStream stream_;
+  AVCodecContext codec_context_;
+};
+
+TEST_F(FFmpegAudioDecoderTest, Initialize) {
+  Initialize();
+
+  EXPECT_EQ(16, decoder_->config().bits_per_channel);
+  EXPECT_EQ(CHANNEL_LAYOUT_STEREO, decoder_->config().channel_layout);
+  EXPECT_EQ(44100, decoder_->config().sample_rate);
+}
+
+TEST_F(FFmpegAudioDecoderTest, Flush) {
+  Initialize();
+  decoder_->Flush(NewExpectedCallback());
+  message_loop_.RunAllPending();
+}
+
+TEST_F(FFmpegAudioDecoderTest, ProduceAudioSamples) {
+  Initialize();
+
+  // First packet doesn't produce audio data, hence only two decode callbacks.
+  EXPECT_CALL(*demuxer_, Read(_))
+      .Times(3)
+      .WillRepeatedly(InvokeReadPacket(this));
+  EXPECT_CALL(statistics_callback_, OnStatistics(_))
+      .Times(3);
+  EXPECT_CALL(*this, DecodeFinished(_))
+      .Times(2);
+
+  // We have to use a buffer to trigger a read. Silly.
+  scoped_refptr<DataBuffer> buffer(0);
+  decoder_->ProduceAudioSamples(buffer);
+  decoder_->ProduceAudioSamples(buffer);
+  decoder_->ProduceAudioSamples(buffer);
+  message_loop_.RunAllPending();
+}
+
+}  // namespace media
+