Refactor audio and video decoder status into common file.

media/filters/audio_decoder_unittest.cc

 // Copyright 2014 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 <stddef.h>
 #include <stdint.h>
 
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 118 matching lines @@
       base::TimeDelta::FromSecondsD(base::ByteSwapToLE32(*skip_samples_ptr) /
                                     samples_per_second),
       base::TimeDelta()));
 }
 
 class AudioDecoderTest : public testing::TestWithParam<DecoderTestData> {
  public:
   AudioDecoderTest()
       : pending_decode_(false),
         pending_reset_(false),
-        last_decode_status_(AudioDecoder::kDecodeError) {
+        last_decode_status_(DecodeStatus::DECODE_ERROR) {
     switch (GetParam().decoder_type) {
       case FFMPEG:
         decoder_.reset(new FFmpegAudioDecoder(message_loop_.task_runner(),
                                               new MediaLog()));
         break;
       case OPUS:
         decoder_.reset(
             new OpusAudioDecoder(message_loop_.task_runner()));
         break;
 #if defined(OS_ANDROID)
       case MEDIA_CODEC:
         decoder_.reset(new MediaCodecAudioDecoder(message_loop_.task_runner()));
         break;
 #endif
     }
   }
 
   virtual ~AudioDecoderTest() {
     EXPECT_FALSE(pending_decode_);
     EXPECT_FALSE(pending_reset_);
   }
 
  protected:
   void DecodeBuffer(const scoped_refptr<DecoderBuffer>& buffer) {
     ASSERT_FALSE(pending_decode_);
     pending_decode_ = true;
-    last_decode_status_ = AudioDecoder::kDecodeError;
+    last_decode_status_ = DecodeStatus::DECODE_ERROR;
 
     base::RunLoop run_loop;
     decoder_->Decode(
         buffer, base::Bind(&AudioDecoderTest::DecodeFinished,
                            base::Unretained(this), run_loop.QuitClosure()));
     run_loop.Run();
     ASSERT_FALSE(pending_decode_);
   }
 
   void SendEndOfStream() {
@@ skipping 92 matching lines @@
     Reset();
     decoded_audio_.clear();
     ASSERT_TRUE(reader_->SeekForTesting(seek_time));
   }
 
   void OnDecoderOutput(const scoped_refptr<AudioBuffer>& buffer) {
     EXPECT_FALSE(buffer->end_of_stream());
     decoded_audio_.push_back(buffer);
   }
 
-  void DecodeFinished(const base::Closure& quit_closure,
-                      AudioDecoder::Status status) {
+  void DecodeFinished(const base::Closure& quit_closure, DecodeStatus status) {
     EXPECT_TRUE(pending_decode_);
     EXPECT_FALSE(pending_reset_);
     pending_decode_ = false;
     last_decode_status_ = status;
     quit_closure.Run();
   }
 
   void ResetFinished() {
     EXPECT_TRUE(pending_reset_);
     EXPECT_FALSE(pending_decode_);
@@ skipping 67 matching lines @@
       if (i > 0)
         EXPECT_NE(exact_hash, GetDecodedAudioMD5(i - 1));
     }
   }
 
   size_t decoded_audio_size() const { return decoded_audio_.size(); }
   base::TimeDelta start_timestamp() const { return start_timestamp_; }
   const scoped_refptr<AudioBuffer>& decoded_audio(size_t i) {
     return decoded_audio_[i];
   }
-  AudioDecoder::Status last_decode_status() const {
-    return last_decode_status_;
-  }
+  DecodeStatus last_decode_status() const { return last_decode_status_; }
 
  private:
   base::MessageLoop message_loop_;
   scoped_refptr<DecoderBuffer> data_;
   scoped_ptr<InMemoryUrlProtocol> protocol_;
   scoped_ptr<AudioFileReader> reader_;
 
   scoped_ptr<AudioDecoder> decoder_;
   bool pending_decode_;
   bool pending_reset_;
-  AudioDecoder::Status last_decode_status_;
+  DecodeStatus last_decode_status_;
 
   std::deque<scoped_refptr<AudioBuffer> > decoded_audio_;
   base::TimeDelta start_timestamp_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioDecoderTest);
 };
 
 class OpusAudioDecoderBehavioralTest : public AudioDecoderTest {};
 class FFmpegAudioDecoderBehavioralTest : public AudioDecoderTest {};
 
 TEST_P(AudioDecoderTest, Initialize) {
   SKIP_TEST_IF_NO_MEDIA_CODEC();
   ASSERT_NO_FATAL_FAILURE(Initialize());
 }
 
 // Verifies decode audio as well as the Decode() -> Reset() sequence.
 TEST_P(AudioDecoderTest, ProduceAudioSamples) {
   SKIP_TEST_IF_NO_MEDIA_CODEC();
   ASSERT_NO_FATAL_FAILURE(Initialize());
 
   // Run the test multiple times with a seek back to the beginning in between.
   std::vector<std::string> decoded_audio_md5_hashes;
   for (int i = 0; i < 2; ++i) {
     // Run decoder until we get at least |kDecodeRuns| output buffers.
     // Keeping Decode() in a loop seems to be the simplest way to guarantee that
     // the predefined number of output buffers are produced without draining
     // (i.e. decoding EOS).
     do {
       Decode();
-      ASSERT_EQ(last_decode_status(), AudioDecoder::kOk);
+      ASSERT_EQ(last_decode_status(), DecodeStatus::OK);
     } while (decoded_audio_size() < kDecodeRuns);
 
     // With MediaCodecAudioDecoder the output buffers might appear after
     // some delay. Since we keep decoding in a loop, the number of output
     // buffers when they eventually appear might exceed |kDecodeRuns|.
     ASSERT_LE(kDecodeRuns, decoded_audio_size());
 
     // On the first pass record the exact MD5 hash for each decoded buffer.
     if (i == 0) {
       for (size_t j = 0; j < kDecodeRuns; ++j)
@@ skipping 11 matching lines @@
 
     // Seek back to the beginning.  Calls Reset() on the decoder.
     Seek(start_timestamp());
   }
 }
 
 TEST_P(AudioDecoderTest, Decode) {
   SKIP_TEST_IF_NO_MEDIA_CODEC();
   ASSERT_NO_FATAL_FAILURE(Initialize());
   Decode();
-  EXPECT_EQ(AudioDecoder::kOk, last_decode_status());
+  EXPECT_EQ(DecodeStatus::OK, last_decode_status());
 }
 
 TEST_P(AudioDecoderTest, Reset) {
   SKIP_TEST_IF_NO_MEDIA_CODEC();
   ASSERT_NO_FATAL_FAILURE(Initialize());
   Reset();
 }
 
 TEST_P(AudioDecoderTest, NoTimestamp) {
   SKIP_TEST_IF_NO_MEDIA_CODEC();
   ASSERT_NO_FATAL_FAILURE(Initialize());
   scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(0));
   buffer->set_timestamp(kNoTimestamp());
   DecodeBuffer(buffer);
-  EXPECT_EQ(AudioDecoder::kDecodeError, last_decode_status());
+  EXPECT_EQ(DecodeStatus::DECODE_ERROR, last_decode_status());
 }
 
 TEST_P(OpusAudioDecoderBehavioralTest, InitializeWithNoCodecDelay) {
   ASSERT_EQ(GetParam().decoder_type, OPUS);
   std::vector<uint8_t> extra_data(
       kOpusExtraData,
       kOpusExtraData + arraysize(kOpusExtraData));
   AudioDecoderConfig decoder_config;
   decoder_config.Initialize(kCodecOpus, kSampleFormatF32, CHANNEL_LAYOUT_STEREO,
                             48000, extra_data, Unencrypted(),
@@ skipping 152 matching lines @@
 };
 
 INSTANTIATE_TEST_CASE_P(FFmpegAudioDecoderTest,
                         AudioDecoderTest,
                         testing::ValuesIn(kFFmpegTests));
 INSTANTIATE_TEST_CASE_P(FFmpegAudioDecoderBehavioralTest,
                         FFmpegAudioDecoderBehavioralTest,
                         testing::ValuesIn(kFFmpegBehavioralTest));
 
 }  // namespace media