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 73 matching lines @@
 
     // 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);
+                       NULL, 0, false, true);
   }
 
   virtual ~FFmpegVideoDecoderTest() {}
 
   void Initialize() {
     InitializeWithConfig(config_);
   }
 
+  void InitializeWithEncryptedConfig() {
+    config_.set_is_encrypted(true);

[acolwell GONE FROM CHROMIUM, 2012/09/17 17:41:17]

Just copy the config_.Initialize() call from above and modify the encryption
bool so you don't need set_is_encrypted().

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

Done.

+    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 127 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, false, false);

[acolwell GONE FROM CHROMIUM, 2012/09/17 17:41:17]

nit: I'm pretty sure this should be 0, false here and below.

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

Oops, thanks for the catch. Done here and blow.

   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, false, 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, false, 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, false, 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, false, 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, false, 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, false, 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, false, 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, false, 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);
@@ skipping 101 matching lines @@
   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);
   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 132 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