Refactor audio and video decoder status into common file.

media/filters/ffmpeg_video_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 <stdint.h>
 
 #include <list>
 #include <string>
 #include <vector>
 
@@ skipping 83 matching lines @@
   }
 
   void Destroy() {
     decoder_.reset();
     message_loop_.RunUntilIdle();
   }
 
   // Sets up expectations and actions to put FFmpegVideoDecoder in an active
   // decoding state.
   void EnterDecodingState() {
-    EXPECT_EQ(VideoDecoder::kOk, DecodeSingleFrame(i_frame_buffer_));
+    EXPECT_EQ(DecodeStatus::OK, DecodeSingleFrame(i_frame_buffer_));
     ASSERT_EQ(1U, output_frames_.size());
   }
 
   // Sets up expectations and actions to put FFmpegVideoDecoder in an end
   // of stream state.
   void EnterEndOfStreamState() {
-    EXPECT_EQ(VideoDecoder::kOk, DecodeSingleFrame(end_of_stream_buffer_));
+    EXPECT_EQ(DecodeStatus::OK, DecodeSingleFrame(end_of_stream_buffer_));
     ASSERT_FALSE(output_frames_.empty());
   }
 
   typedef std::vector<scoped_refptr<DecoderBuffer> > InputBuffers;
   typedef std::vector<scoped_refptr<VideoFrame> > OutputFrames;
 
   // Decodes all buffers in |input_buffers| and push all successfully decoded
   // output frames into |output_frames|.
   // Returns the last decode status returned by the decoder.
-  VideoDecoder::Status DecodeMultipleFrames(const InputBuffers& input_buffers) {
+  DecodeStatus DecodeMultipleFrames(const InputBuffers& input_buffers) {
     for (InputBuffers::const_iterator iter = input_buffers.begin();
          iter != input_buffers.end();
          ++iter) {
-      VideoDecoder::Status status = Decode(*iter);
+      DecodeStatus status = Decode(*iter);
       switch (status) {
-        case VideoDecoder::kOk:
+        case DecodeStatus::OK:
           break;
-        case VideoDecoder::kAborted:
+        case DecodeStatus::ABORTED:
           NOTREACHED();
-        case VideoDecoder::kDecodeError:
+        case DecodeStatus::DECODE_ERROR:
           DCHECK(output_frames_.empty());
           return status;
       }
     }
-    return VideoDecoder::kOk;
+    return DecodeStatus::OK;
   }
 
   // Decodes the single compressed frame in |buffer| and writes the
   // uncompressed output to |video_frame|. This method works with single
   // and multithreaded decoders. End of stream buffers are used to trigger
   // the frame to be returned in the multithreaded decoder case.
-  VideoDecoder::Status DecodeSingleFrame(
-      const scoped_refptr<DecoderBuffer>& buffer) {
+  DecodeStatus DecodeSingleFrame(const scoped_refptr<DecoderBuffer>& buffer) {
     InputBuffers input_buffers;
     input_buffers.push_back(buffer);
     input_buffers.push_back(end_of_stream_buffer_);
 
     return DecodeMultipleFrames(input_buffers);
   }
 
   // Decodes |i_frame_buffer_| and then decodes the data contained in
   // the file named |test_file_name|. This function expects both buffers
   // to decode to frames that are the same size.
   void DecodeIFrameThenTestFile(const std::string& test_file_name,
                                 int expected_width,
                                 int expected_height) {
     Initialize();
     scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(test_file_name);
 
     InputBuffers input_buffers;
     input_buffers.push_back(i_frame_buffer_);
     input_buffers.push_back(buffer);
     input_buffers.push_back(end_of_stream_buffer_);
 
-    VideoDecoder::Status status =
-        DecodeMultipleFrames(input_buffers);
+    DecodeStatus status = DecodeMultipleFrames(input_buffers);
 
-    EXPECT_EQ(VideoDecoder::kOk, status);
+    EXPECT_EQ(DecodeStatus::OK, status);
     ASSERT_EQ(2U, output_frames_.size());
 
     gfx::Size original_size = kVisibleRect.size();
     EXPECT_EQ(original_size.width(),
               output_frames_[0]->visible_rect().size().width());
     EXPECT_EQ(original_size.height(),
               output_frames_[0]->visible_rect().size().height());
     EXPECT_EQ(expected_width,
               output_frames_[1]->visible_rect().size().width());
     EXPECT_EQ(expected_height,
               output_frames_[1]->visible_rect().size().height());
   }
 
-  VideoDecoder::Status Decode(const scoped_refptr<DecoderBuffer>& buffer) {
-    VideoDecoder::Status status;
+  DecodeStatus Decode(const scoped_refptr<DecoderBuffer>& buffer) {
+    DecodeStatus status;
     EXPECT_CALL(*this, DecodeDone(_)).WillOnce(SaveArg<0>(&status));
 
     decoder_->Decode(buffer, decode_cb_);
 
     message_loop_.RunUntilIdle();
 
     return status;
   }
 
   void FrameReady(const scoped_refptr<VideoFrame>& frame) {
     DCHECK(!frame->metadata()->IsTrue(VideoFrameMetadata::END_OF_STREAM));
     output_frames_.push_back(frame);
   }
 
-  MOCK_METHOD1(DecodeDone, void(VideoDecoder::Status));
+  MOCK_METHOD1(DecodeDone, void(DecodeStatus));
 
   base::MessageLoop message_loop_;
   scoped_ptr<FFmpegVideoDecoder> decoder_;
 
   VideoDecoder::DecodeCB decode_cb_;
 
   // Various buffers for testing.
   scoped_ptr<uint8_t[]> frame_buffer_;
   scoped_refptr<DecoderBuffer> end_of_stream_buffer_;
   scoped_refptr<DecoderBuffer> i_frame_buffer_;
@@ skipping 33 matching lines @@
   Initialize();
   EnterDecodingState();
   Reset();
   Reinitialize();
 }
 
 TEST_F(FFmpegVideoDecoderTest, DecodeFrame_Normal) {
   Initialize();
 
   // Simulate decoding a single frame.
-  EXPECT_EQ(VideoDecoder::kOk, DecodeSingleFrame(i_frame_buffer_));
+  EXPECT_EQ(DecodeStatus::OK, DecodeSingleFrame(i_frame_buffer_));
   ASSERT_EQ(1U, output_frames_.size());
 }
 
 // Verify current behavior for 0 byte frames. FFmpeg simply ignores
 // the 0 byte frames.
 TEST_F(FFmpegVideoDecoderTest, DecodeFrame_0ByteFrame) {
   Initialize();
 
   scoped_refptr<DecoderBuffer> zero_byte_buffer = new DecoderBuffer(0);
 
   InputBuffers input_buffers;
   input_buffers.push_back(i_frame_buffer_);
   input_buffers.push_back(zero_byte_buffer);
   input_buffers.push_back(i_frame_buffer_);
   input_buffers.push_back(end_of_stream_buffer_);
 
-  VideoDecoder::Status status = DecodeMultipleFrames(input_buffers);
+  DecodeStatus status = DecodeMultipleFrames(input_buffers);
 
-  EXPECT_EQ(VideoDecoder::kOk, status);
+  EXPECT_EQ(DecodeStatus::OK, status);
   ASSERT_EQ(2U, output_frames_.size());
 }
 
 TEST_F(FFmpegVideoDecoderTest, DecodeFrame_DecodeError) {
   Initialize();
 
   // The error is only raised on the second decode attempt, so we expect at
   // least one successful decode but we don't expect valid frame to be decoded.
   // During the second decode attempt an error is raised.
-  EXPECT_EQ(VideoDecoder::kOk, Decode(corrupt_i_frame_buffer_));
+  EXPECT_EQ(DecodeStatus::OK, Decode(corrupt_i_frame_buffer_));
   EXPECT_TRUE(output_frames_.empty());
-  EXPECT_EQ(VideoDecoder::kDecodeError, Decode(i_frame_buffer_));
+  EXPECT_EQ(DecodeStatus::DECODE_ERROR, Decode(i_frame_buffer_));
   EXPECT_TRUE(output_frames_.empty());
 
   // After a decode error occurred, all following decodes will return
-  // kDecodeError.
-  EXPECT_EQ(VideoDecoder::kDecodeError, Decode(i_frame_buffer_));
+  // DecodeStatus::DECODE_ERROR.
+  EXPECT_EQ(DecodeStatus::DECODE_ERROR, Decode(i_frame_buffer_));
   EXPECT_TRUE(output_frames_.empty());
 }
 
 // A corrupt frame followed by an EOS buffer should raise a decode error.
 TEST_F(FFmpegVideoDecoderTest, DecodeFrame_DecodeErrorAtEndOfStream) {
   Initialize();
 
-  EXPECT_EQ(VideoDecoder::kDecodeError,
+  EXPECT_EQ(DecodeStatus::DECODE_ERROR,
             DecodeSingleFrame(corrupt_i_frame_buffer_));
 }
 
 // Decode |i_frame_buffer_| and then a frame with a larger width and verify
 // the output size was adjusted.
 TEST_F(FFmpegVideoDecoderTest, DecodeFrame_LargerWidth) {
   DecodeIFrameThenTestFile("vp8-I-frame-640x240", 640, 240);
 }
 
 // Decode |i_frame_buffer_| and then a frame with a smaller width and verify
@@ skipping 50 matching lines @@
 
 // Test destruction when decoder has hit end of stream.
 TEST_F(FFmpegVideoDecoderTest, Destroy_EndOfStream) {
   Initialize();
   EnterDecodingState();
   EnterEndOfStreamState();
   Destroy();
 }
 
 }  // namespace media