Add callback in VideoDecoder and AudioDecoder to return decoded frames.

media/filters/video_decoder_selector_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 <vector>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "media/base/gmock_callback_support.h"
 #include "media/base/mock_filters.h"
@@ skipping 95 matching lines @@
         message_loop_.message_loop_proxy(),
         all_decoders_.Pass(),
         set_decryptor_ready_cb));
   }
 
   void SelectDecoder() {
     decoder_selector_->SelectDecoder(
         demuxer_stream_.get(),
         false,
         base::Bind(&VideoDecoderSelectorTest::MockOnDecoderSelected,
+                   base::Unretained(this)),
+        base::Bind(&VideoDecoderSelectorTest::FrameReady,
                    base::Unretained(this)));
     message_loop_.RunUntilIdle();
   }
 
   void SelectDecoderAndAbort() {
     SelectDecoder();
 
     EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull()));
     decoder_selector_->Abort();
     message_loop_.RunUntilIdle();
   }
 
+  void FrameReady(const scoped_refptr<VideoFrame>& frame) {
+    NOTREACHED();
+  }
+
   // Fixture members.
   scoped_ptr<VideoDecoderSelector> decoder_selector_;
   scoped_ptr<StrictMock<MockDemuxerStream> > demuxer_stream_;
   // Use NiceMock since we don't care about most of calls on the decryptor, e.g.
   // RegisterNewKeyCB().
   scoped_ptr<NiceMock<MockDecryptor> > decryptor_;
   StrictMock<MockVideoDecoder>* decoder_1_;
   StrictMock<MockVideoDecoder>* decoder_2_;
   ScopedVector<VideoDecoder> all_decoders_;
 
@@ skipping 20 matching lines @@
 
   SelectDecoder();
 }
 
 // The stream is not encrypted and we have one clear decoder. The decoder
 // will be selected.
 TEST_F(VideoDecoderSelectorTest, ClearStream_NoDecryptor_OneClearDecoder) {
   UseClearStream();
   InitializeDecoderSelector(kNoDecryptor, 1);
 
-  EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
+  EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _))
       .WillOnce(RunCallback<2>(PIPELINE_OK));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull()));
   EXPECT_CALL(*decoder_1_, Stop());
 
   SelectDecoder();
 }
 
 TEST_F(VideoDecoderSelectorTest,
        Abort_ClearStream_NoDecryptor_OneClearDecoder) {
   UseClearStream();
   InitializeDecoderSelector(kNoDecryptor, 1);
 
-  EXPECT_CALL(*decoder_1_, Initialize(_, _, _));
+  EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _));
   EXPECT_CALL(*decoder_1_, Stop());
 
   SelectDecoderAndAbort();
 }
 
 // The stream is not encrypted and we have multiple clear decoders. The first
 // decoder that can decode the input stream will be selected.
 TEST_F(VideoDecoderSelectorTest, ClearStream_NoDecryptor_MultipleClearDecoder) {
   UseClearStream();
   InitializeDecoderSelector(kNoDecryptor, 2);
 
-  EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
+  EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _))
       .WillOnce(RunCallback<2>(DECODER_ERROR_NOT_SUPPORTED));
-  EXPECT_CALL(*decoder_2_, Initialize(_, _, _))
+  EXPECT_CALL(*decoder_2_, Initialize(_, _, _, _))
       .WillOnce(RunCallback<2>(PIPELINE_OK));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, IsNull()));
   EXPECT_CALL(*decoder_2_, Stop());
 
   SelectDecoder();
 }
 
 TEST_F(VideoDecoderSelectorTest,
        Abort_ClearStream_NoDecryptor_MultipleClearDecoder) {
   UseClearStream();
   InitializeDecoderSelector(kNoDecryptor, 2);
 
-  EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
+  EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _))
       .WillOnce(RunCallback<2>(DECODER_ERROR_NOT_SUPPORTED));
-  EXPECT_CALL(*decoder_2_, Initialize(_, _, _));
+  EXPECT_CALL(*decoder_2_, Initialize(_, _, _, _));
   EXPECT_CALL(*decoder_2_, Stop());
 
   SelectDecoderAndAbort();
 }
 
 // There is a decryptor but the stream is not encrypted. The decoder will be
 // selected.
 TEST_F(VideoDecoderSelectorTest, ClearStream_HasDecryptor) {
   UseClearStream();
   InitializeDecoderSelector(kDecryptOnly, 1);
 
-  EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
+  EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _))
       .WillOnce(RunCallback<2>(PIPELINE_OK));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull()));
   EXPECT_CALL(*decoder_1_, Stop());
 
   SelectDecoder();
 }
 
 TEST_F(VideoDecoderSelectorTest, Abort_ClearStream_HasDecryptor) {
   UseClearStream();
   InitializeDecoderSelector(kDecryptOnly, 1);
 
-  EXPECT_CALL(*decoder_1_, Initialize(_, _, _));
+  EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _));
   EXPECT_CALL(*decoder_1_, Stop());
 
   SelectDecoderAndAbort();
 }
 
 // The stream is encrypted and there's no decryptor. No decoder can be selected.
 TEST_F(VideoDecoderSelectorTest, EncryptedStream_NoDecryptor) {
   UseEncryptedStream();
   InitializeDecoderSelector(kNoDecryptor, 1);
 
@@ skipping 20 matching lines @@
 
   SelectDecoderAndAbort();
 }
 
 // Decryptor can do decryption-only and there's a decoder available. The decoder
 // will be selected and a DecryptingDemuxerStream will be created.
 TEST_F(VideoDecoderSelectorTest, EncryptedStream_DecryptOnly_OneClearDecoder) {
   UseEncryptedStream();
   InitializeDecoderSelector(kDecryptOnly, 1);
 
-  EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
+  EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _))
       .WillOnce(RunCallback<2>(PIPELINE_OK));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, NotNull()));
   EXPECT_CALL(*decoder_1_, Stop());
 
   SelectDecoder();
 }
 
 TEST_F(VideoDecoderSelectorTest,
        Abort_EncryptedStream_DecryptOnly_OneClearDecoder) {
   UseEncryptedStream();
   InitializeDecoderSelector(kDecryptOnly, 1);
 
-  EXPECT_CALL(*decoder_1_, Initialize(_, _, _));
+  EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _));
   EXPECT_CALL(*decoder_1_, Stop());
 
   SelectDecoderAndAbort();
 }
 
 // Decryptor can only do decryption and there are multiple decoders available.
 // The first decoder that can decode the input stream will be selected and
 // a DecryptingDemuxerStream will be created.
 TEST_F(VideoDecoderSelectorTest,
        EncryptedStream_DecryptOnly_MultipleClearDecoder) {
   UseEncryptedStream();
   InitializeDecoderSelector(kDecryptOnly, 2);
 
-  EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
+  EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _))
       .WillOnce(RunCallback<2>(DECODER_ERROR_NOT_SUPPORTED));
-  EXPECT_CALL(*decoder_2_, Initialize(_, _, _))
+  EXPECT_CALL(*decoder_2_, Initialize(_, _, _, _))
       .WillOnce(RunCallback<2>(PIPELINE_OK));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, NotNull()));
   EXPECT_CALL(*decoder_2_, Stop());
 
   SelectDecoder();
 }
 
 TEST_F(VideoDecoderSelectorTest,
        Abort_EncryptedStream_DecryptOnly_MultipleClearDecoder) {
   UseEncryptedStream();
   InitializeDecoderSelector(kDecryptOnly, 2);
 
-  EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
+  EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _))
       .WillOnce(RunCallback<2>(DECODER_ERROR_NOT_SUPPORTED));
-  EXPECT_CALL(*decoder_2_, Initialize(_, _, _));
+  EXPECT_CALL(*decoder_2_, Initialize(_, _, _, _));
   EXPECT_CALL(*decoder_2_, Stop());
 
   SelectDecoderAndAbort();
 }
 
 // Decryptor can do decryption and decoding. A DecryptingVideoDecoder will be
 // created and selected. The clear decoders should not be touched at all.
 // No DecryptingDemuxerStream should to be created.
 TEST_F(VideoDecoderSelectorTest, EncryptedStream_DecryptAndDecode) {
   UseEncryptedStream();
   InitializeDecoderSelector(kDecryptAndDecode, 1);
 
   EXPECT_CALL(*this, OnDecoderSelected(NotNull(), IsNull()));
 
   SelectDecoder();
 }
 
 TEST_F(VideoDecoderSelectorTest, Abort_EncryptedStream_DecryptAndDecode) {
   UseEncryptedStream();
   InitializeDecoderSelector(kHoldSetDecryptor, 1);
 
   SelectDecoderAndAbort();
 }
 
 }  // namespace media