Introducing DecoderBuffer and general Buffer cleanup.

media/filters/ffmpeg_video_decoder_unittest.cc

Index: media/filters/ffmpeg_video_decoder_unittest.cc
diff --git a/media/filters/ffmpeg_video_decoder_unittest.cc b/media/filters/ffmpeg_video_decoder_unittest.cc
index 24e716e57b7d379196982562acf69102233f08a0..820434084294ee479020e65124d2e75316d82125 100644
--- a/media/filters/ffmpeg_video_decoder_unittest.cc
+++ b/media/filters/ffmpeg_video_decoder_unittest.cc
@@ -57,11 +57,11 @@ class FFmpegVideoDecoderTest : public testing::Test {
 
     // Initialize various test buffers.
     frame_buffer_.reset(new uint8[kCodedSize.GetArea()]);
-    end_of_stream_buffer_ = new DataBuffer(0);
-    ReadTestDataFile("vp8-I-frame-320x240", &i_frame_buffer_);
-    ReadTestDataFile("vp8-corrupt-I-frame", &corrupt_i_frame_buffer_);
-    ReadTestDataFile("vp8-encrypted-I-frame-320x240",
-                     &encrypted_i_frame_buffer_);
+    end_of_stream_buffer_ = new DecoderBuffer(0);
+    i_frame_buffer_ = ReadTestDataFile("vp8-I-frame-320x240");
+    corrupt_i_frame_buffer_ = ReadTestDataFile("vp8-corrupt-I-frame");
+    encrypted_i_frame_buffer_ = ReadTestDataFile(
+        "vp8-encrypted-I-frame-320x240");
 
     config_.Initialize(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN,
                        kVideoFormat, kCodedSize, kVisibleRect,
@@ -129,7 +129,7 @@ class FFmpegVideoDecoderTest : public testing::Test {
   // 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.
-  void DecodeSingleFrame(const scoped_refptr<Buffer>& buffer,
+  void DecodeSingleFrame(const scoped_refptr<DecoderBuffer>& buffer,
                          VideoDecoder::DecoderStatus* status,
                          scoped_refptr<VideoFrame>* video_frame) {
     EXPECT_CALL(*demuxer_, Read(_))
@@ -154,8 +154,7 @@ class FFmpegVideoDecoderTest : public testing::Test {
     scoped_refptr<VideoFrame> video_frame_a;
     scoped_refptr<VideoFrame> video_frame_b;
 
-    scoped_refptr<Buffer> buffer;
-    ReadTestDataFile(test_file_name, &buffer);
+    scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(test_file_name);
 
     EXPECT_CALL(*demuxer_, Read(_))
         .WillOnce(ReturnBuffer(i_frame_buffer_))
@@ -204,10 +203,10 @@ class FFmpegVideoDecoderTest : public testing::Test {
 
   // Various buffers for testing.
   scoped_array<uint8_t> frame_buffer_;
-  scoped_refptr<Buffer> end_of_stream_buffer_;
-  scoped_refptr<Buffer> i_frame_buffer_;
-  scoped_refptr<Buffer> corrupt_i_frame_buffer_;
-  scoped_refptr<DataBuffer> encrypted_i_frame_buffer_;
+  scoped_refptr<DecoderBuffer> end_of_stream_buffer_;
+  scoped_refptr<DecoderBuffer> i_frame_buffer_;
+  scoped_refptr<DecoderBuffer> corrupt_i_frame_buffer_;
+  scoped_refptr<DecoderBuffer> encrypted_i_frame_buffer_;
 
   // Used for generating timestamped buffers.
   std::deque<int64> timestamps_;
@@ -266,46 +265,6 @@ TEST_F(FFmpegVideoDecoderTest, DecodeFrame_Normal) {
   EXPECT_FALSE(video_frame->IsEndOfStream());
 }
 
-// Verify current behavior for 0 byte frames. FFmpeg simply ignores
-// the 0 byte frames.
-TEST_F(FFmpegVideoDecoderTest, DecodeFrame_0ByteFrame) {

[scherkus (not reviewing), 2012/05/26 01:36:32]

I'd ping acolwell to see if he can remember why we had this

[DaleCurtis, 2012/05/29 21:17:01]

Per acolwell: "The 0-byte frame test was there to make sure FFmpeg didn't do
anything wacky with Theora 0-byte frames. In Theora they encode a 0 byte frame
to indicate that the frame should match the previous one"

Testing shows my new code broke this behavior, I've modified my implementation
such that 0-byte buffers are acceptable and constructing negatived buffers or
copying data from NULL result in NULL data sections.  As such I've undone this
change.

-  Initialize();
-
-  scoped_refptr<DataBuffer> zero_byte_buffer = new DataBuffer(1);
-
-  VideoDecoder::DecoderStatus status_a;
-  VideoDecoder::DecoderStatus status_b;
-  VideoDecoder::DecoderStatus status_c;
-  scoped_refptr<VideoFrame> video_frame_a;
-  scoped_refptr<VideoFrame> video_frame_b;
-  scoped_refptr<VideoFrame> video_frame_c;
-
-  EXPECT_CALL(*demuxer_, Read(_))
-      .WillOnce(ReturnBuffer(i_frame_buffer_))
-      .WillOnce(ReturnBuffer(zero_byte_buffer))
-      .WillOnce(ReturnBuffer(i_frame_buffer_))
-      .WillRepeatedly(ReturnBuffer(end_of_stream_buffer_));
-
-  EXPECT_CALL(statistics_cb_, OnStatistics(_))
-      .Times(2);
-
-  Read(&status_a, &video_frame_a);
-  Read(&status_b, &video_frame_b);
-  Read(&status_c, &video_frame_c);
-
-  EXPECT_EQ(status_a, VideoDecoder::kOk);
-  EXPECT_EQ(status_b, VideoDecoder::kOk);
-  EXPECT_EQ(status_c, VideoDecoder::kOk);
-
-  ASSERT_TRUE(video_frame_a);
-  ASSERT_TRUE(video_frame_b);
-  ASSERT_TRUE(video_frame_c);
-
-  EXPECT_FALSE(video_frame_a->IsEndOfStream());
-  EXPECT_FALSE(video_frame_b->IsEndOfStream());
-  EXPECT_TRUE(video_frame_c->IsEndOfStream());
-}
-
 TEST_F(FFmpegVideoDecoderTest, DecodeFrame_DecodeError) {
   Initialize();
 
@@ -514,7 +473,7 @@ TEST_F(FFmpegVideoDecoderTest, AbortPendingRead) {
   Initialize();
 
   EXPECT_CALL(*demuxer_, Read(_))
-      .WillOnce(ReturnBuffer(scoped_refptr<Buffer>()));
+      .WillOnce(ReturnBuffer(scoped_refptr<DecoderBuffer>()));
 
   VideoDecoder::DecoderStatus status;
   scoped_refptr<VideoFrame> video_frame;