Update Decryptor interface to support audio decoding.

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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop.h"
@@ skipping 45 matching lines @@
       encrypted_frame_offset,
       std::vector<SubsampleEntry>())));
   return buffer;
 }
 
 ACTION_P(ReturnBuffer, buffer) {
   arg0.Run(buffer ? DemuxerStream::kOk : DemuxerStream::kAborted, buffer);
 }
 
 ACTION_P2(RunDecryptCB, status, buffer) {
-  arg1.Run(status, buffer);
+  arg2.Run(status, buffer);
 }
 
 class FFmpegVideoDecoderTest : public testing::Test {
  public:
   FFmpegVideoDecoderTest()
       : decryptor_(new MockDecryptor()),
         decoder_(NULL),
         demuxer_(new StrictMock<MockDemuxerStream>()),
         read_cb_(base::Bind(&FFmpegVideoDecoderTest::FrameReady,
                             base::Unretained(this))) {
@@ skipping 39 matching lines @@
                          base::Bind(&MockStatisticsCB::OnStatistics,
                                     base::Unretained(&statistics_cb_)));
 
     message_loop_.RunAllPending();
   }
 
   void InitializeWithConfig(const VideoDecoderConfig& config) {
     InitializeWithConfigAndStatus(config, PIPELINE_OK);
   }
 
-  void CancelDecrypt() {
+  void CancelDecrypt(Decryptor::StreamType stream_type) {
     if (!decrypt_cb_.is_null()) {
        base::ResetAndReturn(&decrypt_cb_).Run(
            Decryptor::kError, scoped_refptr<DecoderBuffer>(NULL));
     }
   }
 
   void Reset() {
-    EXPECT_CALL(*decryptor_, CancelDecrypt())
+    EXPECT_CALL(*decryptor_, CancelDecrypt(Decryptor::kVideo))
         .WillOnce(Invoke(this, &FFmpegVideoDecoderTest::CancelDecrypt));
     decoder_->Reset(NewExpectedClosure());
     message_loop_.RunAllPending();
   }
 
   void Stop() {
     // Use AtMost(1) here because CancelDecrypt() will be called once if the
     // decoder was initialized and has not been stopped, and will not be
     // called otherwise.
-    EXPECT_CALL(*decryptor_, CancelDecrypt())
+    EXPECT_CALL(*decryptor_, CancelDecrypt(Decryptor::kVideo))
         .Times(AtMost(1))
         .WillRepeatedly(Invoke(this, &FFmpegVideoDecoderTest::CancelDecrypt));
     decoder_->Stop(NewExpectedClosure());
     message_loop_.RunAllPending();
   }
 
   // Sets up expectations and actions to put FFmpegVideoDecoder in an active
   // decoding state.
   void EnterDecodingState() {
     VideoDecoder::Status status;
@@ skipping 305 matching lines @@
 // 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) {
   InitializeWithEncryptedConfig();
 
   // Simulate decoding a single encrypted frame.
-  EXPECT_CALL(*decryptor_, Decrypt(encrypted_i_frame_buffer_, _))
+  EXPECT_CALL(*decryptor_,
+              Decrypt(Decryptor::kVideo, 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(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) {
   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_, _))
+  EXPECT_CALL(*decryptor_,
+              Decrypt(Decryptor::kVideo, 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) {
   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_, _))
+  EXPECT_CALL(*decryptor_,
+              Decrypt(Decryptor::kVideo, 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) {
   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_, _))
+  EXPECT_CALL(*decryptor_,
+              Decrypt(Decryptor::kVideo, encrypted_i_frame_buffer_, _))
       .WillRepeatedly(RunDecryptCB(Decryptor::kSuccess,
                                    corrupt_i_frame_buffer_));
   // The decoder only detects the error at the second decoding call. So
   // |statistics_cb_| still gets called once.
   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;
@@ skipping 48 matching lines @@
   read_cb.Run(DemuxerStream::kOk, i_frame_buffer_);
   message_loop_.RunAllPending();
 }
 
 // Test resetting when there is a pending decrypt on the decryptor.
 TEST_F(FFmpegVideoDecoderTest, Reset_DuringPendingDecrypt) {
   InitializeWithEncryptedConfig();
 
   EXPECT_CALL(*demuxer_, Read(_))
       .WillRepeatedly(ReturnBuffer(encrypted_i_frame_buffer_));
-  EXPECT_CALL(*decryptor_, Decrypt(encrypted_i_frame_buffer_, _))
-      .WillOnce(SaveArg<1>(&decrypt_cb_));
+  EXPECT_CALL(*decryptor_,
+              Decrypt(Decryptor::kVideo, encrypted_i_frame_buffer_, _))
+      .WillOnce(SaveArg<2>(&decrypt_cb_));
 
   decoder_->Read(read_cb_);
   message_loop_.RunAllPending();
   // Make sure the Read() on the decoder triggers a Decrypt() on the decryptor.
   EXPECT_FALSE(decrypt_cb_.is_null());
 
   EXPECT_CALL(*this, FrameReady(VideoDecoder::kOk, IsNull()));
   Reset();
   message_loop_.RunAllPending();
 }
@@ skipping 40 matching lines @@
   read_cb.Run(DemuxerStream::kOk, i_frame_buffer_);
   message_loop_.RunAllPending();
 }
 
 // Test stopping when there is a pending decrypt on the decryptor.
 TEST_F(FFmpegVideoDecoderTest, Stop_DuringPendingDecrypt) {
   InitializeWithEncryptedConfig();
 
   EXPECT_CALL(*demuxer_, Read(_))
       .WillRepeatedly(ReturnBuffer(encrypted_i_frame_buffer_));
-  EXPECT_CALL(*decryptor_, Decrypt(encrypted_i_frame_buffer_, _))
-      .WillOnce(SaveArg<1>(&decrypt_cb_));
+  EXPECT_CALL(*decryptor_,
+              Decrypt(Decryptor::kVideo, encrypted_i_frame_buffer_, _))
+      .WillOnce(SaveArg<2>(&decrypt_cb_));
 
   decoder_->Read(read_cb_);
   message_loop_.RunAllPending();
   // Make sure the Read() on the decoder triggers a Decrypt() on the decryptor.
   EXPECT_FALSE(decrypt_cb_.is_null());
 
   EXPECT_CALL(*this, FrameReady(VideoDecoder::kOk, IsNull()));
   Stop();
   message_loop_.RunAllPending();
 }
@@ skipping 33 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