OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <vector> | 5 #include <vector> |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/message_loop/message_loop.h" | 8 #include "base/message_loop/message_loop.h" |
9 #include "media/base/gmock_callback_support.h" | 9 #include "media/base/gmock_callback_support.h" |
10 #include "media/base/mock_filters.h" | 10 #include "media/base/mock_filters.h" |
11 #include "media/base/test_helpers.h" | 11 #include "media/base/test_helpers.h" |
12 #include "media/filters/decoder_selector.h" | 12 #include "media/filters/decoder_selector.h" |
13 #include "media/filters/decrypting_demuxer_stream.h" | 13 #include "media/filters/decrypting_demuxer_stream.h" |
14 #include "testing/gtest/include/gtest/gtest.h" | 14 #include "testing/gtest/include/gtest/gtest.h" |
15 | 15 |
16 using ::testing::_; | 16 using ::testing::_; |
17 using ::testing::Eq; | |
17 using ::testing::IsNull; | 18 using ::testing::IsNull; |
18 using ::testing::NiceMock; | 19 using ::testing::NiceMock; |
19 using ::testing::NotNull; | 20 using ::testing::NotNull; |
20 using ::testing::Return; | 21 using ::testing::Return; |
21 using ::testing::StrictMock; | 22 using ::testing::StrictMock; |
22 | 23 |
24 // Use anonymous namespace here to prevent the actions to be defined multiple | |
25 // times across multiple test files. Sadly we can't use static for them. | |
26 namespace { | |
27 | |
28 ACTION_P3(ExecuteCallbackWithVerifier, decryptor, done_cb, verifier) { | |
29 // verifier must be called first since |done_cb| call will invoke it as well. | |
30 verifier->A(); | |
31 arg0.Run(decryptor, done_cb); | |
32 } | |
33 | |
34 ACTION_P(CheckCallbackHappenedUsingVerifier, verifier) { | |
ddorwin
2014/08/08 21:15:26
ditto
jrummell
2014/08/08 23:39:59
Acknowledged.
| |
35 verifier->B(); | |
36 } | |
37 | |
38 } // namespace | |
39 | |
23 namespace media { | 40 namespace media { |
24 | 41 |
25 class VideoDecoderSelectorTest : public ::testing::Test { | 42 class VideoDecoderSelectorTest : public ::testing::Test { |
26 public: | 43 public: |
27 enum DecryptorCapability { | 44 enum DecryptorCapability { |
28 kNoDecryptor, | 45 kNoDecryptor, |
29 // Used to test destruction during DecryptingVideoDecoder::Initialize() and | 46 // Used to test destruction during DecryptingVideoDecoder::Initialize() and |
30 // DecryptingDemuxerStream::Initialize(). We don't need this for normal | 47 // DecryptingDemuxerStream::Initialize(). We don't need this for normal |
31 // VideoDecoders since we use MockVideoDecoder. | 48 // VideoDecoders since we use MockVideoDecoder. |
32 kHoldSetDecryptor, | 49 kHoldSetDecryptor, |
(...skipping 11 matching lines...) Expand all Loading... | |
44 all_decoders_.push_back(decoder_2_); | 61 all_decoders_.push_back(decoder_2_); |
45 } | 62 } |
46 | 63 |
47 ~VideoDecoderSelectorTest() { | 64 ~VideoDecoderSelectorTest() { |
48 message_loop_.RunUntilIdle(); | 65 message_loop_.RunUntilIdle(); |
49 } | 66 } |
50 | 67 |
51 MOCK_METHOD1(SetDecryptorReadyCallback, void(const media::DecryptorReadyCB&)); | 68 MOCK_METHOD1(SetDecryptorReadyCallback, void(const media::DecryptorReadyCB&)); |
52 MOCK_METHOD2(OnDecoderSelected, | 69 MOCK_METHOD2(OnDecoderSelected, |
53 void(VideoDecoder*, DecryptingDemuxerStream*)); | 70 void(VideoDecoder*, DecryptingDemuxerStream*)); |
71 MOCK_METHOD1(DecryptorSet, void(bool)); | |
54 | 72 |
55 void MockOnDecoderSelected( | 73 void MockOnDecoderSelected( |
56 scoped_ptr<VideoDecoder> decoder, | 74 scoped_ptr<VideoDecoder> decoder, |
57 scoped_ptr<DecryptingDemuxerStream> stream) { | 75 scoped_ptr<DecryptingDemuxerStream> stream) { |
58 OnDecoderSelected(decoder.get(), stream.get()); | 76 OnDecoderSelected(decoder.get(), stream.get()); |
59 selected_decoder_ = decoder.Pass(); | 77 selected_decoder_ = decoder.Pass(); |
60 } | 78 } |
61 | 79 |
62 void UseClearStream() { | 80 void UseClearStream() { |
63 demuxer_stream_->set_video_decoder_config(TestVideoConfig::Normal()); | 81 demuxer_stream_->set_video_decoder_config(TestVideoConfig::Normal()); |
64 } | 82 } |
65 | 83 |
66 void UseEncryptedStream() { | 84 void UseEncryptedStream() { |
67 demuxer_stream_->set_video_decoder_config( | 85 demuxer_stream_->set_video_decoder_config( |
68 TestVideoConfig::NormalEncrypted()); | 86 TestVideoConfig::NormalEncrypted()); |
69 } | 87 } |
70 | 88 |
71 void InitializeDecoderSelector(DecryptorCapability decryptor_capability, | 89 void InitializeDecoderSelector(DecryptorCapability decryptor_capability, |
72 int num_decoders) { | 90 int num_decoders) { |
73 SetDecryptorReadyCB set_decryptor_ready_cb; | 91 SetDecryptorReadyCB set_decryptor_ready_cb; |
74 if (decryptor_capability != kNoDecryptor) { | 92 if (decryptor_capability != kNoDecryptor) { |
75 set_decryptor_ready_cb = | 93 set_decryptor_ready_cb = |
76 base::Bind(&VideoDecoderSelectorTest::SetDecryptorReadyCallback, | 94 base::Bind(&VideoDecoderSelectorTest::SetDecryptorReadyCallback, |
77 base::Unretained(this)); | 95 base::Unretained(this)); |
78 } | 96 } |
79 | 97 |
80 if (decryptor_capability == kDecryptOnly || | 98 if (decryptor_capability == kDecryptOnly || |
81 decryptor_capability == kDecryptAndDecode) { | 99 decryptor_capability == kDecryptAndDecode) { |
82 EXPECT_CALL(*this, SetDecryptorReadyCallback(_)) | 100 EXPECT_CALL(*this, SetDecryptorReadyCallback(_)) |
83 .WillRepeatedly(RunCallback<0>(decryptor_.get())); | 101 .WillRepeatedly(ExecuteCallbackWithVerifier( |
102 decryptor_.get(), | |
103 base::Bind(&VideoDecoderSelectorTest::DecryptorSet, | |
104 base::Unretained(this)), | |
105 &verifier_)); | |
106 EXPECT_CALL(*this, DecryptorSet(Eq(true))) | |
107 .WillRepeatedly(CheckCallbackHappenedUsingVerifier(&verifier_)); | |
84 | 108 |
85 if (decryptor_capability == kDecryptOnly) { | 109 if (decryptor_capability == kDecryptOnly) { |
86 EXPECT_CALL(*decryptor_, InitializeVideoDecoder(_, _)) | 110 EXPECT_CALL(*decryptor_, InitializeVideoDecoder(_, _)) |
87 .WillRepeatedly(RunCallback<1>(false)); | 111 .WillRepeatedly(RunCallback<1>(false)); |
88 } else { | 112 } else { |
89 EXPECT_CALL(*decryptor_, InitializeVideoDecoder(_, _)) | 113 EXPECT_CALL(*decryptor_, InitializeVideoDecoder(_, _)) |
90 .WillRepeatedly(RunCallback<1>(true)); | 114 .WillRepeatedly(RunCallback<1>(true)); |
91 } | 115 } |
92 } else if (decryptor_capability == kHoldSetDecryptor) { | 116 } else if (decryptor_capability == kHoldSetDecryptor) { |
93 // Set and cancel DecryptorReadyCB but the callback is never fired. | 117 // Set and cancel DecryptorReadyCB but the callback is never fired. |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
138 | 162 |
139 scoped_ptr<VideoDecoderSelector> decoder_selector_; | 163 scoped_ptr<VideoDecoderSelector> decoder_selector_; |
140 | 164 |
141 StrictMock<MockVideoDecoder>* decoder_1_; | 165 StrictMock<MockVideoDecoder>* decoder_1_; |
142 StrictMock<MockVideoDecoder>* decoder_2_; | 166 StrictMock<MockVideoDecoder>* decoder_2_; |
143 ScopedVector<VideoDecoder> all_decoders_; | 167 ScopedVector<VideoDecoder> all_decoders_; |
144 scoped_ptr<VideoDecoder> selected_decoder_; | 168 scoped_ptr<VideoDecoder> selected_decoder_; |
145 | 169 |
146 base::MessageLoop message_loop_; | 170 base::MessageLoop message_loop_; |
147 | 171 |
172 MatchingCallbackVerifier verifier_; | |
173 | |
148 private: | 174 private: |
149 DISALLOW_COPY_AND_ASSIGN(VideoDecoderSelectorTest); | 175 DISALLOW_COPY_AND_ASSIGN(VideoDecoderSelectorTest); |
150 }; | 176 }; |
151 | 177 |
152 // The stream is not encrypted but we have no clear decoder. No decoder can be | 178 // The stream is not encrypted but we have no clear decoder. No decoder can be |
153 // selected. | 179 // selected. |
154 TEST_F(VideoDecoderSelectorTest, ClearStream_NoDecryptor_NoClearDecoder) { | 180 TEST_F(VideoDecoderSelectorTest, ClearStream_NoDecryptor_NoClearDecoder) { |
155 UseClearStream(); | 181 UseClearStream(); |
156 InitializeDecoderSelector(kNoDecryptor, 0); | 182 InitializeDecoderSelector(kNoDecryptor, 0); |
157 | 183 |
(...skipping 168 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
326 } | 352 } |
327 | 353 |
328 TEST_F(VideoDecoderSelectorTest, Destroy_EncryptedStream_DecryptAndDecode) { | 354 TEST_F(VideoDecoderSelectorTest, Destroy_EncryptedStream_DecryptAndDecode) { |
329 UseEncryptedStream(); | 355 UseEncryptedStream(); |
330 InitializeDecoderSelector(kHoldSetDecryptor, 1); | 356 InitializeDecoderSelector(kHoldSetDecryptor, 1); |
331 | 357 |
332 SelectDecoderAndDestroy(); | 358 SelectDecoderAndDestroy(); |
333 } | 359 } |
334 | 360 |
335 } // namespace media | 361 } // namespace media |
OLD | NEW |