Add is_encrypted() in VideoDecoderConfig.

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 <deque>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
@@ skipping 70 matching lines @@
         base::Bind(&Identity<scoped_refptr<base::MessageLoopProxy> >,
                    message_loop_.message_loop_proxy()),
         decryptor_.get());
 
     // Initialize various test buffers.
     frame_buffer_.reset(new uint8[kCodedSize.GetArea()]);
     end_of_stream_buffer_ = DecoderBuffer::CreateEOSBuffer();
     i_frame_buffer_ = ReadTestDataFile("vp8-I-frame-320x240");
     corrupt_i_frame_buffer_ = ReadTestDataFile("vp8-corrupt-I-frame");
     encrypted_i_frame_buffer_ = CreateFakeEncryptedBuffer();
-
-    config_.Initialize(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN,
-                       kVideoFormat, kCodedSize, kVisibleRect, kNaturalSize,
-                       NULL, 0, true);
   }
 
   virtual ~FFmpegVideoDecoderTest() {}
 
   void Initialize() {
+    config_.Initialize(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, kVideoFormat,
+                       kCodedSize, kVisibleRect, kNaturalSize,
+                       NULL, 0, false, true);
     InitializeWithConfig(config_);
   }
 
+  void InitializeWithEncryptedConfig() {
+    config_.Initialize(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, kVideoFormat,
+                       kCodedSize, kVisibleRect, kNaturalSize,
+                       NULL, 0, true, true);
+    InitializeWithConfig(config_);
+  }
+
   void InitializeWithConfigAndStatus(const VideoDecoderConfig& config,
                                      PipelineStatus status) {
     EXPECT_CALL(*demuxer_, video_decoder_config())
         .WillRepeatedly(ReturnRef(config));
 
     decoder_->Initialize(demuxer_, NewExpectedStatusCB(status),
                          base::Bind(&MockStatisticsCB::OnStatistics,
                                     base::Unretained(&statistics_cb_)));
 
     message_loop_.RunAllPending();
@@ skipping 13 matching lines @@
     message_loop_.RunAllPending();
   }
 
   // Sets up expectations and actions to put FFmpegVideoDecoder in an active
   // decoding state.
   void EnterDecodingState() {
     VideoDecoder::Status status;
     scoped_refptr<VideoFrame> video_frame;
     DecodeSingleFrame(i_frame_buffer_, &status, &video_frame);
 
-    EXPECT_EQ(status, VideoDecoder::kOk);
+    EXPECT_EQ(VideoDecoder::kOk, status);

[xhwang, 2012/09/17 19:42:25]

Changed the order here since otherwise it gives funny results when the
expectation is not satisfied as follows:
 Value of: VideoDecoder::kOk
  Actual: 0
Expected: status
Which is: 1

     ASSERT_TRUE(video_frame);
     EXPECT_FALSE(video_frame->IsEndOfStream());
   }
 
   // Sets up expectations and actions to put FFmpegVideoDecoder in an end
   // of stream state.
   void EnterEndOfStreamState() {
     scoped_refptr<VideoFrame> video_frame;
     VideoDecoder::Status status;
     Read(&status, &video_frame);
-    EXPECT_EQ(status, VideoDecoder::kOk);
+    EXPECT_EQ(VideoDecoder::kOk, status);
     ASSERT_TRUE(video_frame);
     EXPECT_TRUE(video_frame->IsEndOfStream());
   }
 
   // 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.
   void DecodeSingleFrame(const scoped_refptr<DecoderBuffer>& buffer,
                          VideoDecoder::Status* status,
@@ skipping 27 matching lines @@
         .WillOnce(ReturnBuffer(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);
 
     gfx::Size original_size = kVisibleRect.size();
-    EXPECT_EQ(status_a, VideoDecoder::kOk);
-    EXPECT_EQ(status_b, VideoDecoder::kOk);
+    EXPECT_EQ(VideoDecoder::kOk, status_a);
+    EXPECT_EQ(VideoDecoder::kOk, status_b);
     ASSERT_TRUE(video_frame_a);
     ASSERT_TRUE(video_frame_b);
     EXPECT_EQ(original_size.width(), video_frame_a->data_size().width());
     EXPECT_EQ(original_size.height(), video_frame_a->data_size().height());
     EXPECT_EQ(expected_width, video_frame_b->data_size().width());
     EXPECT_EQ(expected_height, video_frame_b->data_size().height());
   }
 
   void Read(VideoDecoder::Status* status,
             scoped_refptr<VideoFrame>* video_frame) {
@@ skipping 33 matching lines @@
 
 TEST_F(FFmpegVideoDecoderTest, Initialize_Normal) {
   Initialize();
 }
 
 TEST_F(FFmpegVideoDecoderTest, Initialize_UnsupportedDecoder) {
   // Test avcodec_find_decoder() returning NULL.
   VideoDecoderConfig config(kUnknownVideoCodec, VIDEO_CODEC_PROFILE_UNKNOWN,
                             kVideoFormat,
                             kCodedSize, kVisibleRect, kNaturalSize,
-                            NULL, 0);
+                            NULL, 0, false);
   InitializeWithConfigAndStatus(config, PIPELINE_ERROR_DECODE);
 }
 
 TEST_F(FFmpegVideoDecoderTest, Initialize_UnsupportedPixelFormat) {
   // Ensure decoder handles unsupport pixel formats without crashing.
   VideoDecoderConfig config(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN,
                             VideoFrame::INVALID,
                             kCodedSize, kVisibleRect, kNaturalSize,
-                            NULL, 0);
+                            NULL, 0, false);
   InitializeWithConfigAndStatus(config, PIPELINE_ERROR_DECODE);
 }
 
 TEST_F(FFmpegVideoDecoderTest, Initialize_OpenDecoderFails) {
   // Specify Theora w/o extra data so that avcodec_open2() fails.
   VideoDecoderConfig config(kCodecTheora, VIDEO_CODEC_PROFILE_UNKNOWN,
                             kVideoFormat,
                             kCodedSize, kVisibleRect, kNaturalSize,
-                            NULL, 0);
+                            NULL, 0, false);
   InitializeWithConfigAndStatus(config, PIPELINE_ERROR_DECODE);
 }
 
 TEST_F(FFmpegVideoDecoderTest, Initialize_AspectRatioNumeratorZero) {
   gfx::Size natural_size = GetNaturalSize(kVisibleRect.size(), 0, 1);
   VideoDecoderConfig config(kCodecVP8, VP8PROFILE_MAIN,
                             kVideoFormat,
                             kCodedSize, kVisibleRect, natural_size,
-                            NULL, 0);
+                            NULL, 0, false);
   InitializeWithConfigAndStatus(config, PIPELINE_ERROR_DECODE);
 }
 
 TEST_F(FFmpegVideoDecoderTest, Initialize_AspectRatioDenominatorZero) {
   gfx::Size natural_size = GetNaturalSize(kVisibleRect.size(), 1, 0);
   VideoDecoderConfig config(kCodecVP8, VP8PROFILE_MAIN,
                             kVideoFormat,
                             kCodedSize, kVisibleRect, natural_size,
-                            NULL, 0);
+                            NULL, 0, false);
   InitializeWithConfigAndStatus(config, PIPELINE_ERROR_DECODE);
 }
 
 TEST_F(FFmpegVideoDecoderTest, Initialize_AspectRatioNumeratorNegative) {
   gfx::Size natural_size = GetNaturalSize(kVisibleRect.size(), -1, 1);
   VideoDecoderConfig config(kCodecVP8, VP8PROFILE_MAIN,
                             kVideoFormat,
                             kCodedSize, kVisibleRect, natural_size,
-                            NULL, 0);
+                            NULL, 0, false);
   InitializeWithConfigAndStatus(config, PIPELINE_ERROR_DECODE);
 }
 
 TEST_F(FFmpegVideoDecoderTest, Initialize_AspectRatioDenominatorNegative) {
   gfx::Size natural_size = GetNaturalSize(kVisibleRect.size(), 1, -1);
   VideoDecoderConfig config(kCodecVP8, VP8PROFILE_MAIN,
                             kVideoFormat,
                             kCodedSize, kVisibleRect, natural_size,
-                            NULL, 0);
+                            NULL, 0, false);
   InitializeWithConfigAndStatus(config, PIPELINE_ERROR_DECODE);
 }
 
 TEST_F(FFmpegVideoDecoderTest, Initialize_AspectRatioNumeratorTooLarge) {
   int width = kVisibleRect.size().width();
   int num = ceil(static_cast<double>(limits::kMaxDimension + 1) / width);
   gfx::Size natural_size = GetNaturalSize(kVisibleRect.size(), num, 1);
   VideoDecoderConfig config(kCodecVP8, VP8PROFILE_MAIN,
                             kVideoFormat,
                             kCodedSize, kVisibleRect, natural_size,
-                            NULL, 0);
+                            NULL, 0, false);
   InitializeWithConfigAndStatus(config, PIPELINE_ERROR_DECODE);
 }
 
 TEST_F(FFmpegVideoDecoderTest, Initialize_AspectRatioDenominatorTooLarge) {
   int den = kVisibleRect.size().width() + 1;
   gfx::Size natural_size = GetNaturalSize(kVisibleRect.size(), 1, den);
   VideoDecoderConfig config(kCodecVP8, VP8PROFILE_MAIN,
                             kVideoFormat,
                             kCodedSize, kVisibleRect, natural_size,
-                            NULL, 0);
+                            NULL, 0, false);
   InitializeWithConfigAndStatus(config, PIPELINE_ERROR_DECODE);
 }
 
 TEST_F(FFmpegVideoDecoderTest, DecodeFrame_Normal) {
   Initialize();
 
   // Simulate decoding a single frame.
   VideoDecoder::Status status;
   scoped_refptr<VideoFrame> video_frame;
   DecodeSingleFrame(i_frame_buffer_, &status, &video_frame);
 
-  EXPECT_EQ(status, VideoDecoder::kOk);
+  EXPECT_EQ(VideoDecoder::kOk, status);
   ASSERT_TRUE(video_frame);
   EXPECT_FALSE(video_frame->IsEndOfStream());
 }
 
 // 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);
@@ skipping 11 matching lines @@
       .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);
+  EXPECT_EQ(VideoDecoder::kOk, status_a);
+  EXPECT_EQ(VideoDecoder::kOk, status_b);
+  EXPECT_EQ(VideoDecoder::kOk, status_c);
 
   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();
 
   EXPECT_CALL(*demuxer_, Read(_))
       .WillOnce(ReturnBuffer(corrupt_i_frame_buffer_))
       .WillRepeatedly(ReturnBuffer(i_frame_buffer_));
 
   // The error is only raised on the second decode attempt, so we expect at
   // least one successful decode but we don't expect FrameReady() to be
   // executed as an error is raised instead.
   EXPECT_CALL(statistics_cb_, OnStatistics(_));
 
   // Our read should still get satisfied with end of stream frame during an
   // error.
   VideoDecoder::Status status;
   scoped_refptr<VideoFrame> video_frame;
   Read(&status, &video_frame);
-  EXPECT_EQ(status, VideoDecoder::kDecodeError);
+  EXPECT_EQ(VideoDecoder::kDecodeError, status);
   EXPECT_FALSE(video_frame);
 
   message_loop_.RunAllPending();
 }
 
 // Multi-threaded decoders have different behavior than single-threaded
 // decoders at the end of the stream. Multithreaded decoders hide errors
 // that happen on the last |codec_context_->thread_count| frames to avoid
 // prematurely signalling EOS. This test just exposes that behavior so we can
 // detect if it changes.
 TEST_F(FFmpegVideoDecoderTest, DecodeFrame_DecodeErrorAtEndOfStream) {
   Initialize();
 
   VideoDecoder::Status status;
   scoped_refptr<VideoFrame> video_frame;
   DecodeSingleFrame(corrupt_i_frame_buffer_, &status, &video_frame);
 
-  EXPECT_EQ(status, VideoDecoder::kOk);
+  EXPECT_EQ(VideoDecoder::kOk, status);
   ASSERT_TRUE(video_frame);
   EXPECT_TRUE(video_frame->IsEndOfStream());
 }
 
 // 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
 // the output size was adjusted.
 TEST_F(FFmpegVideoDecoderTest, DecodeFrame_SmallerWidth) {
   DecodeIFrameThenTestFile("vp8-I-frame-160x240", 160, 240);
 }
 
 // Decode |i_frame_buffer_| and then a frame with a larger height and verify
 // the output size was adjusted.
 TEST_F(FFmpegVideoDecoderTest, DecodeFrame_LargerHeight) {
   DecodeIFrameThenTestFile("vp8-I-frame-320x480", 320, 480);
 }
 
 // Decode |i_frame_buffer_| and then a frame with a smaller height and verify
 // the output size was adjusted.
 TEST_F(FFmpegVideoDecoderTest, DecodeFrame_SmallerHeight) {
   DecodeIFrameThenTestFile("vp8-I-frame-320x120", 320, 120);
 }
 
 TEST_F(FFmpegVideoDecoderTest, DecodeEncryptedFrame_Normal) {
-  Initialize();
+  InitializeWithEncryptedConfig();
 
   // Simulate decoding a single encrypted frame.
   EXPECT_CALL(*decryptor_, Decrypt(encrypted_i_frame_buffer_, _))
       .WillRepeatedly(RunDecryptCB(Decryptor::kSuccess, i_frame_buffer_));
 
   VideoDecoder::Status status;
   scoped_refptr<VideoFrame> video_frame;
   DecodeSingleFrame(encrypted_i_frame_buffer_, &status, &video_frame);
 
-  EXPECT_EQ(status, VideoDecoder::kOk);
+  EXPECT_EQ(VideoDecoder::kOk, status);
   ASSERT_TRUE(video_frame);
   EXPECT_FALSE(video_frame->IsEndOfStream());
 }
 
 // Test the case that the decryptor fails to decrypt the encrypted buffer.
 TEST_F(FFmpegVideoDecoderTest, DecodeEncryptedFrame_DecryptError) {
-  Initialize();
+  InitializeWithEncryptedConfig();
 
   // Simulate decoding a single encrypted frame.
   EXPECT_CALL(*demuxer_, Read(_))
       .WillRepeatedly(ReturnBuffer(encrypted_i_frame_buffer_));
   EXPECT_CALL(*decryptor_, Decrypt(encrypted_i_frame_buffer_, _))
       .WillRepeatedly(RunDecryptCB(Decryptor::kError,
                                    scoped_refptr<media::DecoderBuffer>()));
 
   // Our read should still get satisfied with end of stream frame during an
   // error.
   VideoDecoder::Status status;
   scoped_refptr<VideoFrame> video_frame;
   Read(&status, &video_frame);
   EXPECT_EQ(VideoDecoder::kDecryptError, status);
   EXPECT_FALSE(video_frame);
 
   message_loop_.RunAllPending();
 }
 
 // Test the case that the decryptor has no key to decrypt the encrypted buffer.
 TEST_F(FFmpegVideoDecoderTest, DecodeEncryptedFrame_NoDecryptionKey) {
-  Initialize();
+  InitializeWithEncryptedConfig();
 
   // Simulate decoding a single encrypted frame.
   EXPECT_CALL(*demuxer_, Read(_))
       .WillRepeatedly(ReturnBuffer(encrypted_i_frame_buffer_));
   EXPECT_CALL(*decryptor_, Decrypt(encrypted_i_frame_buffer_, _))
       .WillRepeatedly(RunDecryptCB(Decryptor::kNoKey,
                                    scoped_refptr<media::DecoderBuffer>()));
 
   // Our read should still get satisfied with end of stream frame during an
   // error.
   VideoDecoder::Status status;
   scoped_refptr<VideoFrame> video_frame;
   Read(&status, &video_frame);
   EXPECT_EQ(VideoDecoder::kDecryptError, status);
   EXPECT_FALSE(video_frame);
 
   message_loop_.RunAllPending();
 }
 
 // Test the case that the decryptor fails to decrypt the encrypted buffer but
 // cannot detect the decryption error and returns a corrupted buffer.
 TEST_F(FFmpegVideoDecoderTest, DecodeEncryptedFrame_CorruptedBufferReturned) {
-  Initialize();
+  InitializeWithEncryptedConfig();
 
   // Simulate decoding a single encrypted frame.
   EXPECT_CALL(*demuxer_, Read(_))
       .WillRepeatedly(ReturnBuffer(encrypted_i_frame_buffer_));
   EXPECT_CALL(*decryptor_, Decrypt(encrypted_i_frame_buffer_, _))
       .WillRepeatedly(RunDecryptCB(Decryptor::kSuccess,
                                    corrupt_i_frame_buffer_));
 
   // Our read should still get satisfied with end of stream frame during an
   // error.
@@ skipping 101 matching lines @@
   Initialize();
 
   EXPECT_CALL(*demuxer_, Read(_))
       .WillOnce(ReturnBuffer(scoped_refptr<DecoderBuffer>()));
 
   VideoDecoder::Status status;
   scoped_refptr<VideoFrame> video_frame;
 
   Read(&status, &video_frame);
 
-  EXPECT_EQ(status, VideoDecoder::kOk);
+  EXPECT_EQ(VideoDecoder::kOk, status);
   EXPECT_FALSE(video_frame);
 }
 
 // Test aborted read on the demuxer stream.
 TEST_F(FFmpegVideoDecoderTest, AbortPendingReadDuringFlush) {
   Initialize();
 
   DemuxerStream::ReadCB read_cb;
 
   // Request a read on the decoder and run the MessageLoop to
@@ skipping 10 matching lines @@
 
   // Signal an aborted demuxer read.
   read_cb.Run(DemuxerStream::kAborted, NULL);
 
   // Make sure we get a NULL video frame returned.
   EXPECT_CALL(*this, FrameReady(VideoDecoder::kOk, IsNull()));
   message_loop_.RunAllPending();
 }
 
 }  // namespace media