Add callback in VideoDecoder and AudioDecoder to return decoded frames.

media/filters/decrypting_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/message_loop.h"
@@ skipping 68 matching lines @@
   }
 
   virtual ~DecryptingVideoDecoderTest() {
     Stop();
   }
 
   // Initializes the |decoder_| and expects |status|. Note the initialization
   // can succeed or fail.
   void InitializeAndExpectStatus(const VideoDecoderConfig& config,
                                  PipelineStatus status) {
-    decoder_->Initialize(config, false, NewExpectedStatusCB(status));
+    decoder_->Initialize(config, false, NewExpectedStatusCB(status),
+                         base::Bind(&DecryptingVideoDecoderTest::FrameReady,
+                                    base::Unretained(this)));
     message_loop_.RunUntilIdle();
   }
 
   // Initialize the |decoder_| and expects it to succeed.
   void Initialize() {
     EXPECT_CALL(*decryptor_, InitializeVideoDecoder(_, _))
         .WillOnce(RunCallback<1>(true));
     EXPECT_CALL(*decryptor_, RegisterNewKeyCB(Decryptor::kVideo, _))
         .WillOnce(SaveArg<1>(&key_added_cb_));
 
     InitializeAndExpectStatus(TestVideoConfig::NormalEncrypted(), PIPELINE_OK);
   }
 
   // Reinitialize the |decoder_| and expects it to succeed.
   void Reinitialize() {
     EXPECT_CALL(*decryptor_, DeinitializeDecoder(Decryptor::kVideo));
     EXPECT_CALL(*decryptor_, InitializeVideoDecoder(_, _))
         .WillOnce(RunCallback<1>(true));
     EXPECT_CALL(*decryptor_, RegisterNewKeyCB(Decryptor::kVideo, _))
         .WillOnce(SaveArg<1>(&key_added_cb_));
 
     InitializeAndExpectStatus(TestVideoConfig::LargeEncrypted(), PIPELINE_OK);
   }
 
   void ReadAndExpectFrameReadyWith(
       const scoped_refptr<DecoderBuffer>& buffer,
       VideoDecoder::Status status,
       const scoped_refptr<VideoFrame>& video_frame) {
-    if (status != VideoDecoder::kOk)
-      EXPECT_CALL(*this, FrameReady(status, IsNull()));
-    else if (video_frame.get() && video_frame->end_of_stream())
-      EXPECT_CALL(*this, FrameReady(status, IsEndOfStream()));
-    else
-      EXPECT_CALL(*this, FrameReady(status, video_frame));
+    if (video_frame.get()) {
+      if (video_frame->end_of_stream()) {
+        EXPECT_CALL(*this, FrameReady(IsEndOfStream()));
+      } else {
+        EXPECT_CALL(*this, FrameReady(video_frame));
+      }
+    }
+    EXPECT_CALL(*this, DecodeDone(status));
 
     decoder_->Decode(buffer,
-                     base::Bind(&DecryptingVideoDecoderTest::FrameReady,
+                     base::Bind(&DecryptingVideoDecoderTest::DecodeDone,
                                 base::Unretained(this)));
     message_loop_.RunUntilIdle();
   }
 
   // Sets up expectations and actions to put DecryptingVideoDecoder in an
   // active normal decoding state.
   void EnterNormalDecodingState() {
     EXPECT_CALL(*decryptor_, DecryptAndDecodeVideo(_, _))
         .WillOnce(RunCallback<1>(Decryptor::kSuccess, decoded_video_frame_))
         .WillRepeatedly(RunCallback<1>(Decryptor::kNeedMoreData,
@@ skipping 11 matching lines @@
                                 end_of_stream_video_frame_);
   }
 
   // Make the video decode callback pending by saving and not firing it.
   void EnterPendingDecodeState() {
     EXPECT_TRUE(pending_video_decode_cb_.is_null());
     EXPECT_CALL(*decryptor_, DecryptAndDecodeVideo(encrypted_buffer_, _))
         .WillOnce(SaveArg<1>(&pending_video_decode_cb_));
 
     decoder_->Decode(encrypted_buffer_,
-                     base::Bind(&DecryptingVideoDecoderTest::FrameReady,
+                     base::Bind(&DecryptingVideoDecoderTest::DecodeDone,
                                 base::Unretained(this)));
     message_loop_.RunUntilIdle();
     // Make sure the Decode() on the decoder triggers a DecryptAndDecode() on
     // the decryptor.
     EXPECT_FALSE(pending_video_decode_cb_.is_null());
   }
 
   void EnterWaitingForKeyState() {
     EXPECT_CALL(*decryptor_, DecryptAndDecodeVideo(_, _))
         .WillRepeatedly(RunCallback<1>(Decryptor::kNoKey, null_video_frame_));
     decoder_->Decode(encrypted_buffer_,
-                     base::Bind(&DecryptingVideoDecoderTest::FrameReady,
+                     base::Bind(&DecryptingVideoDecoderTest::DecodeDone,
                                 base::Unretained(this)));
     message_loop_.RunUntilIdle();
   }
 
   void AbortPendingVideoDecodeCB() {
     if (!pending_video_decode_cb_.is_null()) {
       base::ResetAndReturn(&pending_video_decode_cb_).Run(
           Decryptor::kSuccess, scoped_refptr<VideoFrame>(NULL));
     }
   }
@@ skipping 21 matching lines @@
     EXPECT_CALL(*decryptor_, DeinitializeDecoder(Decryptor::kVideo))
         .WillRepeatedly(InvokeWithoutArgs(
             this, &DecryptingVideoDecoderTest::AbortAllPendingCBs));
 
     decoder_->Stop();
     message_loop_.RunUntilIdle();
   }
 
   MOCK_METHOD1(RequestDecryptorNotification, void(const DecryptorReadyCB&));
 
-  MOCK_METHOD2(FrameReady, void(VideoDecoder::Status,
-                                const scoped_refptr<VideoFrame>&));
+  MOCK_METHOD1(FrameReady, void(const scoped_refptr<VideoFrame>&));
+  MOCK_METHOD1(DecodeDone, void(VideoDecoder::Status));
 
   base::MessageLoop message_loop_;
   scoped_ptr<DecryptingVideoDecoder> decoder_;
   scoped_ptr<StrictMock<MockDecryptor> > decryptor_;
 
   Decryptor::DecoderInitCB pending_init_cb_;
   Decryptor::NewKeyCB key_added_cb_;
   Decryptor::VideoDecodeCB pending_video_decode_cb_;
 
   // Constant buffer/frames.
@@ skipping 75 matching lines @@
 TEST_F(DecryptingVideoDecoderTest, DecryptAndDecode_NeedMoreData) {
   Initialize();
 
   EXPECT_CALL(*decryptor_, DecryptAndDecodeVideo(_, _))
       .WillOnce(RunCallback<1>(Decryptor::kNeedMoreData,
                              scoped_refptr<VideoFrame>()))
       .WillRepeatedly(RunCallback<1>(Decryptor::kSuccess,
                                      decoded_video_frame_));
 
   ReadAndExpectFrameReadyWith(
-      encrypted_buffer_, VideoDecoder::kNotEnoughData, decoded_video_frame_);
+      encrypted_buffer_, VideoDecoder::kOk, NULL);
   ReadAndExpectFrameReadyWith(
       encrypted_buffer_, VideoDecoder::kOk, decoded_video_frame_);
 }
 
 // Test the case where the decryptor receives end-of-stream buffer.
 TEST_F(DecryptingVideoDecoderTest, DecryptAndDecode_EndOfStream) {
   Initialize();
   EnterNormalDecodingState();
   EnterEndOfStreamState();
 }
 
 // Test the case where the a key is added when the decryptor is in
 // kWaitingForKey state.
 TEST_F(DecryptingVideoDecoderTest, KeyAdded_DuringWaitingForKey) {
   Initialize();
   EnterWaitingForKeyState();
 
   EXPECT_CALL(*decryptor_, DecryptAndDecodeVideo(_, _))
       .WillRepeatedly(RunCallback<1>(Decryptor::kSuccess,
                                      decoded_video_frame_));
-  EXPECT_CALL(*this, FrameReady(VideoDecoder::kOk, decoded_video_frame_));
+  EXPECT_CALL(*this, FrameReady(decoded_video_frame_));
+  EXPECT_CALL(*this, DecodeDone(VideoDecoder::kOk));
   key_added_cb_.Run();
   message_loop_.RunUntilIdle();
 }
 
 // Test the case where the a key is added when the decryptor is in
 // kPendingDecode state.
 TEST_F(DecryptingVideoDecoderTest, KeyAdded_DruingPendingDecode) {
   Initialize();
   EnterPendingDecodeState();
 
   EXPECT_CALL(*decryptor_, DecryptAndDecodeVideo(_, _))
       .WillRepeatedly(RunCallback<1>(Decryptor::kSuccess,
                                      decoded_video_frame_));
-  EXPECT_CALL(*this, FrameReady(VideoDecoder::kOk, decoded_video_frame_));
+  EXPECT_CALL(*this, FrameReady(decoded_video_frame_));
+  EXPECT_CALL(*this, DecodeDone(VideoDecoder::kOk));
   // The video decode callback is returned after the correct decryption key is
   // added.
   key_added_cb_.Run();
   base::ResetAndReturn(&pending_video_decode_cb_).Run(Decryptor::kNoKey,
                                                       null_video_frame_);
   message_loop_.RunUntilIdle();
 }
 
 // Test resetting when the decoder is in kIdle state but has not decoded any
 // frame.
 TEST_F(DecryptingVideoDecoderTest, Reset_DuringIdleAfterInitialization) {
   Initialize();
   Reset();
 }
 
 // Test resetting when the decoder is in kIdle state after it has decoded one
 // frame.
 TEST_F(DecryptingVideoDecoderTest, Reset_DuringIdleAfterDecodedOneFrame) {
   Initialize();
   EnterNormalDecodingState();
   Reset();
 }
 
 // Test resetting when the decoder is in kPendingDecode state.
 TEST_F(DecryptingVideoDecoderTest, Reset_DuringPendingDecode) {
   Initialize();
   EnterPendingDecodeState();
 
-  EXPECT_CALL(*this, FrameReady(VideoDecoder::kAborted, IsNull()));
+  EXPECT_CALL(*this, DecodeDone(VideoDecoder::kAborted));
 
   Reset();
 }
 
 // Test resetting when the decoder is in kWaitingForKey state.
 TEST_F(DecryptingVideoDecoderTest, Reset_DuringWaitingForKey) {
   Initialize();
   EnterWaitingForKeyState();
 
-  EXPECT_CALL(*this, FrameReady(VideoDecoder::kAborted, IsNull()));
+  EXPECT_CALL(*this, DecodeDone(VideoDecoder::kAborted));
 
   Reset();
 }
 
 // Test resetting when the decoder has hit end of stream and is in
 // kDecodeFinished state.
 TEST_F(DecryptingVideoDecoderTest, Reset_AfterDecodeFinished) {
   Initialize();
   EnterNormalDecodingState();
   EnterEndOfStreamState();
   Reset();
 }
 
 // Test resetting after the decoder has been reset.
 TEST_F(DecryptingVideoDecoderTest, Reset_AfterReset) {
   Initialize();
   EnterNormalDecodingState();
   Reset();
   Reset();
 }
 
 // Test stopping when the decoder is in kDecryptorRequested state.
 TEST_F(DecryptingVideoDecoderTest, Stop_DuringDecryptorRequested) {
   DecryptorReadyCB decryptor_ready_cb;
   EXPECT_CALL(*this, RequestDecryptorNotification(_))
       .WillOnce(SaveArg<0>(&decryptor_ready_cb));
-  decoder_->Initialize(TestVideoConfig::NormalEncrypted(), false,
-                       NewExpectedStatusCB(DECODER_ERROR_NOT_SUPPORTED));
+  decoder_->Initialize(TestVideoConfig::NormalEncrypted(),
+                       false,
+                       NewExpectedStatusCB(DECODER_ERROR_NOT_SUPPORTED),
+                       base::Bind(&DecryptingVideoDecoderTest::FrameReady,
+                                  base::Unretained(this)));
   message_loop_.RunUntilIdle();
   // |decryptor_ready_cb| is saved but not called here.
   EXPECT_FALSE(decryptor_ready_cb.is_null());
 
   // During stop, RequestDecryptorNotification() should be called with a NULL
   // callback to cancel the |decryptor_ready_cb|.
   EXPECT_CALL(*this, RequestDecryptorNotification(IsNullCallback()))
       .WillOnce(ResetAndRunCallback(&decryptor_ready_cb,
                                     reinterpret_cast<Decryptor*>(NULL)));
   Stop();
@@ skipping 24 matching lines @@
   Initialize();
   EnterNormalDecodingState();
   Stop();
 }
 
 // Test stopping when the decoder is in kPendingDecode state.
 TEST_F(DecryptingVideoDecoderTest, Stop_DuringPendingDecode) {
   Initialize();
   EnterPendingDecodeState();
 
-  EXPECT_CALL(*this, FrameReady(VideoDecoder::kAborted, IsNull()));
+  EXPECT_CALL(*this, DecodeDone(VideoDecoder::kAborted));
 
   Stop();
 }
 
 // Test stopping when the decoder is in kWaitingForKey state.
 TEST_F(DecryptingVideoDecoderTest, Stop_DuringWaitingForKey) {
   Initialize();
   EnterWaitingForKeyState();
 
-  EXPECT_CALL(*this, FrameReady(VideoDecoder::kAborted, IsNull()));
+  EXPECT_CALL(*this, DecodeDone(VideoDecoder::kAborted));
 
   Stop();
 }
 
 // Test stopping when the decoder has hit end of stream and is in
 // kDecodeFinished state.
 TEST_F(DecryptingVideoDecoderTest, Stop_AfterDecodeFinished) {
   Initialize();
   EnterNormalDecodingState();
   EnterEndOfStreamState();
   Stop();
 }
 
 // Test stopping when there is a pending reset on the decoder.
 // Reset is pending because it cannot complete when the video decode callback
 // is pending.
 TEST_F(DecryptingVideoDecoderTest, Stop_DuringPendingReset) {
   Initialize();
   EnterPendingDecodeState();
 
   EXPECT_CALL(*decryptor_, ResetDecoder(Decryptor::kVideo));
-  EXPECT_CALL(*this, FrameReady(VideoDecoder::kAborted, IsNull()));
+  EXPECT_CALL(*this, DecodeDone(VideoDecoder::kAborted));
 
   decoder_->Reset(NewExpectedClosure());
   Stop();
 }
 
 // Test stopping after the decoder has been reset.
 TEST_F(DecryptingVideoDecoderTest, Stop_AfterReset) {
   Initialize();
   EnterNormalDecodingState();
   Reset();
   Stop();
 }
 
 // Test stopping after the decoder has been stopped.
 TEST_F(DecryptingVideoDecoderTest, Stop_AfterStop) {
   Initialize();
   EnterNormalDecodingState();
   Stop();
   Stop();
 }
 
 }  // namespace media