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" |
(...skipping 95 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
106 message_loop_.message_loop_proxy(), | 106 message_loop_.message_loop_proxy(), |
107 all_decoders_.Pass(), | 107 all_decoders_.Pass(), |
108 set_decryptor_ready_cb)); | 108 set_decryptor_ready_cb)); |
109 } | 109 } |
110 | 110 |
111 void SelectDecoder() { | 111 void SelectDecoder() { |
112 decoder_selector_->SelectDecoder( | 112 decoder_selector_->SelectDecoder( |
113 demuxer_stream_.get(), | 113 demuxer_stream_.get(), |
114 false, | 114 false, |
115 base::Bind(&VideoDecoderSelectorTest::MockOnDecoderSelected, | 115 base::Bind(&VideoDecoderSelectorTest::MockOnDecoderSelected, |
| 116 base::Unretained(this)), |
| 117 base::Bind(&VideoDecoderSelectorTest::FrameReady, |
116 base::Unretained(this))); | 118 base::Unretained(this))); |
117 message_loop_.RunUntilIdle(); | 119 message_loop_.RunUntilIdle(); |
118 } | 120 } |
119 | 121 |
120 void SelectDecoderAndAbort() { | 122 void SelectDecoderAndAbort() { |
121 SelectDecoder(); | 123 SelectDecoder(); |
122 | 124 |
123 EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull())); | 125 EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull())); |
124 decoder_selector_->Abort(); | 126 decoder_selector_->Abort(); |
125 message_loop_.RunUntilIdle(); | 127 message_loop_.RunUntilIdle(); |
126 } | 128 } |
127 | 129 |
| 130 void FrameReady(const scoped_refptr<VideoFrame>& frame) { |
| 131 NOTREACHED(); |
| 132 } |
| 133 |
128 // Fixture members. | 134 // Fixture members. |
129 scoped_ptr<VideoDecoderSelector> decoder_selector_; | 135 scoped_ptr<VideoDecoderSelector> decoder_selector_; |
130 scoped_ptr<StrictMock<MockDemuxerStream> > demuxer_stream_; | 136 scoped_ptr<StrictMock<MockDemuxerStream> > demuxer_stream_; |
131 // Use NiceMock since we don't care about most of calls on the decryptor, e.g. | 137 // Use NiceMock since we don't care about most of calls on the decryptor, e.g. |
132 // RegisterNewKeyCB(). | 138 // RegisterNewKeyCB(). |
133 scoped_ptr<NiceMock<MockDecryptor> > decryptor_; | 139 scoped_ptr<NiceMock<MockDecryptor> > decryptor_; |
134 StrictMock<MockVideoDecoder>* decoder_1_; | 140 StrictMock<MockVideoDecoder>* decoder_1_; |
135 StrictMock<MockVideoDecoder>* decoder_2_; | 141 StrictMock<MockVideoDecoder>* decoder_2_; |
136 ScopedVector<VideoDecoder> all_decoders_; | 142 ScopedVector<VideoDecoder> all_decoders_; |
137 | 143 |
(...skipping 20 matching lines...) Expand all Loading... |
158 | 164 |
159 SelectDecoder(); | 165 SelectDecoder(); |
160 } | 166 } |
161 | 167 |
162 // The stream is not encrypted and we have one clear decoder. The decoder | 168 // The stream is not encrypted and we have one clear decoder. The decoder |
163 // will be selected. | 169 // will be selected. |
164 TEST_F(VideoDecoderSelectorTest, ClearStream_NoDecryptor_OneClearDecoder) { | 170 TEST_F(VideoDecoderSelectorTest, ClearStream_NoDecryptor_OneClearDecoder) { |
165 UseClearStream(); | 171 UseClearStream(); |
166 InitializeDecoderSelector(kNoDecryptor, 1); | 172 InitializeDecoderSelector(kNoDecryptor, 1); |
167 | 173 |
168 EXPECT_CALL(*decoder_1_, Initialize(_, _, _)) | 174 EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _)) |
169 .WillOnce(RunCallback<2>(PIPELINE_OK)); | 175 .WillOnce(RunCallback<2>(PIPELINE_OK)); |
170 EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull())); | 176 EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull())); |
171 EXPECT_CALL(*decoder_1_, Stop()); | 177 EXPECT_CALL(*decoder_1_, Stop()); |
172 | 178 |
173 SelectDecoder(); | 179 SelectDecoder(); |
174 } | 180 } |
175 | 181 |
176 TEST_F(VideoDecoderSelectorTest, | 182 TEST_F(VideoDecoderSelectorTest, |
177 Abort_ClearStream_NoDecryptor_OneClearDecoder) { | 183 Abort_ClearStream_NoDecryptor_OneClearDecoder) { |
178 UseClearStream(); | 184 UseClearStream(); |
179 InitializeDecoderSelector(kNoDecryptor, 1); | 185 InitializeDecoderSelector(kNoDecryptor, 1); |
180 | 186 |
181 EXPECT_CALL(*decoder_1_, Initialize(_, _, _)); | 187 EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _)); |
182 EXPECT_CALL(*decoder_1_, Stop()); | 188 EXPECT_CALL(*decoder_1_, Stop()); |
183 | 189 |
184 SelectDecoderAndAbort(); | 190 SelectDecoderAndAbort(); |
185 } | 191 } |
186 | 192 |
187 // The stream is not encrypted and we have multiple clear decoders. The first | 193 // The stream is not encrypted and we have multiple clear decoders. The first |
188 // decoder that can decode the input stream will be selected. | 194 // decoder that can decode the input stream will be selected. |
189 TEST_F(VideoDecoderSelectorTest, ClearStream_NoDecryptor_MultipleClearDecoder) { | 195 TEST_F(VideoDecoderSelectorTest, ClearStream_NoDecryptor_MultipleClearDecoder) { |
190 UseClearStream(); | 196 UseClearStream(); |
191 InitializeDecoderSelector(kNoDecryptor, 2); | 197 InitializeDecoderSelector(kNoDecryptor, 2); |
192 | 198 |
193 EXPECT_CALL(*decoder_1_, Initialize(_, _, _)) | 199 EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _)) |
194 .WillOnce(RunCallback<2>(DECODER_ERROR_NOT_SUPPORTED)); | 200 .WillOnce(RunCallback<2>(DECODER_ERROR_NOT_SUPPORTED)); |
195 EXPECT_CALL(*decoder_2_, Initialize(_, _, _)) | 201 EXPECT_CALL(*decoder_2_, Initialize(_, _, _, _)) |
196 .WillOnce(RunCallback<2>(PIPELINE_OK)); | 202 .WillOnce(RunCallback<2>(PIPELINE_OK)); |
197 EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, IsNull())); | 203 EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, IsNull())); |
198 EXPECT_CALL(*decoder_2_, Stop()); | 204 EXPECT_CALL(*decoder_2_, Stop()); |
199 | 205 |
200 SelectDecoder(); | 206 SelectDecoder(); |
201 } | 207 } |
202 | 208 |
203 TEST_F(VideoDecoderSelectorTest, | 209 TEST_F(VideoDecoderSelectorTest, |
204 Abort_ClearStream_NoDecryptor_MultipleClearDecoder) { | 210 Abort_ClearStream_NoDecryptor_MultipleClearDecoder) { |
205 UseClearStream(); | 211 UseClearStream(); |
206 InitializeDecoderSelector(kNoDecryptor, 2); | 212 InitializeDecoderSelector(kNoDecryptor, 2); |
207 | 213 |
208 EXPECT_CALL(*decoder_1_, Initialize(_, _, _)) | 214 EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _)) |
209 .WillOnce(RunCallback<2>(DECODER_ERROR_NOT_SUPPORTED)); | 215 .WillOnce(RunCallback<2>(DECODER_ERROR_NOT_SUPPORTED)); |
210 EXPECT_CALL(*decoder_2_, Initialize(_, _, _)); | 216 EXPECT_CALL(*decoder_2_, Initialize(_, _, _, _)); |
211 EXPECT_CALL(*decoder_2_, Stop()); | 217 EXPECT_CALL(*decoder_2_, Stop()); |
212 | 218 |
213 SelectDecoderAndAbort(); | 219 SelectDecoderAndAbort(); |
214 } | 220 } |
215 | 221 |
216 // There is a decryptor but the stream is not encrypted. The decoder will be | 222 // There is a decryptor but the stream is not encrypted. The decoder will be |
217 // selected. | 223 // selected. |
218 TEST_F(VideoDecoderSelectorTest, ClearStream_HasDecryptor) { | 224 TEST_F(VideoDecoderSelectorTest, ClearStream_HasDecryptor) { |
219 UseClearStream(); | 225 UseClearStream(); |
220 InitializeDecoderSelector(kDecryptOnly, 1); | 226 InitializeDecoderSelector(kDecryptOnly, 1); |
221 | 227 |
222 EXPECT_CALL(*decoder_1_, Initialize(_, _, _)) | 228 EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _)) |
223 .WillOnce(RunCallback<2>(PIPELINE_OK)); | 229 .WillOnce(RunCallback<2>(PIPELINE_OK)); |
224 EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull())); | 230 EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull())); |
225 EXPECT_CALL(*decoder_1_, Stop()); | 231 EXPECT_CALL(*decoder_1_, Stop()); |
226 | 232 |
227 SelectDecoder(); | 233 SelectDecoder(); |
228 } | 234 } |
229 | 235 |
230 TEST_F(VideoDecoderSelectorTest, Abort_ClearStream_HasDecryptor) { | 236 TEST_F(VideoDecoderSelectorTest, Abort_ClearStream_HasDecryptor) { |
231 UseClearStream(); | 237 UseClearStream(); |
232 InitializeDecoderSelector(kDecryptOnly, 1); | 238 InitializeDecoderSelector(kDecryptOnly, 1); |
233 | 239 |
234 EXPECT_CALL(*decoder_1_, Initialize(_, _, _)); | 240 EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _)); |
235 EXPECT_CALL(*decoder_1_, Stop()); | 241 EXPECT_CALL(*decoder_1_, Stop()); |
236 | 242 |
237 SelectDecoderAndAbort(); | 243 SelectDecoderAndAbort(); |
238 } | 244 } |
239 | 245 |
240 // The stream is encrypted and there's no decryptor. No decoder can be selected. | 246 // The stream is encrypted and there's no decryptor. No decoder can be selected. |
241 TEST_F(VideoDecoderSelectorTest, EncryptedStream_NoDecryptor) { | 247 TEST_F(VideoDecoderSelectorTest, EncryptedStream_NoDecryptor) { |
242 UseEncryptedStream(); | 248 UseEncryptedStream(); |
243 InitializeDecoderSelector(kNoDecryptor, 1); | 249 InitializeDecoderSelector(kNoDecryptor, 1); |
244 | 250 |
(...skipping 20 matching lines...) Expand all Loading... |
265 | 271 |
266 SelectDecoderAndAbort(); | 272 SelectDecoderAndAbort(); |
267 } | 273 } |
268 | 274 |
269 // Decryptor can do decryption-only and there's a decoder available. The decoder | 275 // Decryptor can do decryption-only and there's a decoder available. The decoder |
270 // will be selected and a DecryptingDemuxerStream will be created. | 276 // will be selected and a DecryptingDemuxerStream will be created. |
271 TEST_F(VideoDecoderSelectorTest, EncryptedStream_DecryptOnly_OneClearDecoder) { | 277 TEST_F(VideoDecoderSelectorTest, EncryptedStream_DecryptOnly_OneClearDecoder) { |
272 UseEncryptedStream(); | 278 UseEncryptedStream(); |
273 InitializeDecoderSelector(kDecryptOnly, 1); | 279 InitializeDecoderSelector(kDecryptOnly, 1); |
274 | 280 |
275 EXPECT_CALL(*decoder_1_, Initialize(_, _, _)) | 281 EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _)) |
276 .WillOnce(RunCallback<2>(PIPELINE_OK)); | 282 .WillOnce(RunCallback<2>(PIPELINE_OK)); |
277 EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, NotNull())); | 283 EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, NotNull())); |
278 EXPECT_CALL(*decoder_1_, Stop()); | 284 EXPECT_CALL(*decoder_1_, Stop()); |
279 | 285 |
280 SelectDecoder(); | 286 SelectDecoder(); |
281 } | 287 } |
282 | 288 |
283 TEST_F(VideoDecoderSelectorTest, | 289 TEST_F(VideoDecoderSelectorTest, |
284 Abort_EncryptedStream_DecryptOnly_OneClearDecoder) { | 290 Abort_EncryptedStream_DecryptOnly_OneClearDecoder) { |
285 UseEncryptedStream(); | 291 UseEncryptedStream(); |
286 InitializeDecoderSelector(kDecryptOnly, 1); | 292 InitializeDecoderSelector(kDecryptOnly, 1); |
287 | 293 |
288 EXPECT_CALL(*decoder_1_, Initialize(_, _, _)); | 294 EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _)); |
289 EXPECT_CALL(*decoder_1_, Stop()); | 295 EXPECT_CALL(*decoder_1_, Stop()); |
290 | 296 |
291 SelectDecoderAndAbort(); | 297 SelectDecoderAndAbort(); |
292 } | 298 } |
293 | 299 |
294 // Decryptor can only do decryption and there are multiple decoders available. | 300 // Decryptor can only do decryption and there are multiple decoders available. |
295 // The first decoder that can decode the input stream will be selected and | 301 // The first decoder that can decode the input stream will be selected and |
296 // a DecryptingDemuxerStream will be created. | 302 // a DecryptingDemuxerStream will be created. |
297 TEST_F(VideoDecoderSelectorTest, | 303 TEST_F(VideoDecoderSelectorTest, |
298 EncryptedStream_DecryptOnly_MultipleClearDecoder) { | 304 EncryptedStream_DecryptOnly_MultipleClearDecoder) { |
299 UseEncryptedStream(); | 305 UseEncryptedStream(); |
300 InitializeDecoderSelector(kDecryptOnly, 2); | 306 InitializeDecoderSelector(kDecryptOnly, 2); |
301 | 307 |
302 EXPECT_CALL(*decoder_1_, Initialize(_, _, _)) | 308 EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _)) |
303 .WillOnce(RunCallback<2>(DECODER_ERROR_NOT_SUPPORTED)); | 309 .WillOnce(RunCallback<2>(DECODER_ERROR_NOT_SUPPORTED)); |
304 EXPECT_CALL(*decoder_2_, Initialize(_, _, _)) | 310 EXPECT_CALL(*decoder_2_, Initialize(_, _, _, _)) |
305 .WillOnce(RunCallback<2>(PIPELINE_OK)); | 311 .WillOnce(RunCallback<2>(PIPELINE_OK)); |
306 EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, NotNull())); | 312 EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, NotNull())); |
307 EXPECT_CALL(*decoder_2_, Stop()); | 313 EXPECT_CALL(*decoder_2_, Stop()); |
308 | 314 |
309 SelectDecoder(); | 315 SelectDecoder(); |
310 } | 316 } |
311 | 317 |
312 TEST_F(VideoDecoderSelectorTest, | 318 TEST_F(VideoDecoderSelectorTest, |
313 Abort_EncryptedStream_DecryptOnly_MultipleClearDecoder) { | 319 Abort_EncryptedStream_DecryptOnly_MultipleClearDecoder) { |
314 UseEncryptedStream(); | 320 UseEncryptedStream(); |
315 InitializeDecoderSelector(kDecryptOnly, 2); | 321 InitializeDecoderSelector(kDecryptOnly, 2); |
316 | 322 |
317 EXPECT_CALL(*decoder_1_, Initialize(_, _, _)) | 323 EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _)) |
318 .WillOnce(RunCallback<2>(DECODER_ERROR_NOT_SUPPORTED)); | 324 .WillOnce(RunCallback<2>(DECODER_ERROR_NOT_SUPPORTED)); |
319 EXPECT_CALL(*decoder_2_, Initialize(_, _, _)); | 325 EXPECT_CALL(*decoder_2_, Initialize(_, _, _, _)); |
320 EXPECT_CALL(*decoder_2_, Stop()); | 326 EXPECT_CALL(*decoder_2_, Stop()); |
321 | 327 |
322 SelectDecoderAndAbort(); | 328 SelectDecoderAndAbort(); |
323 } | 329 } |
324 | 330 |
325 // Decryptor can do decryption and decoding. A DecryptingVideoDecoder will be | 331 // Decryptor can do decryption and decoding. A DecryptingVideoDecoder will be |
326 // created and selected. The clear decoders should not be touched at all. | 332 // created and selected. The clear decoders should not be touched at all. |
327 // No DecryptingDemuxerStream should to be created. | 333 // No DecryptingDemuxerStream should to be created. |
328 TEST_F(VideoDecoderSelectorTest, EncryptedStream_DecryptAndDecode) { | 334 TEST_F(VideoDecoderSelectorTest, EncryptedStream_DecryptAndDecode) { |
329 UseEncryptedStream(); | 335 UseEncryptedStream(); |
330 InitializeDecoderSelector(kDecryptAndDecode, 1); | 336 InitializeDecoderSelector(kDecryptAndDecode, 1); |
331 | 337 |
332 EXPECT_CALL(*this, OnDecoderSelected(NotNull(), IsNull())); | 338 EXPECT_CALL(*this, OnDecoderSelected(NotNull(), IsNull())); |
333 | 339 |
334 SelectDecoder(); | 340 SelectDecoder(); |
335 } | 341 } |
336 | 342 |
337 TEST_F(VideoDecoderSelectorTest, Abort_EncryptedStream_DecryptAndDecode) { | 343 TEST_F(VideoDecoderSelectorTest, Abort_EncryptedStream_DecryptAndDecode) { |
338 UseEncryptedStream(); | 344 UseEncryptedStream(); |
339 InitializeDecoderSelector(kHoldSetDecryptor, 1); | 345 InitializeDecoderSelector(kHoldSetDecryptor, 1); |
340 | 346 |
341 SelectDecoderAndAbort(); | 347 SelectDecoderAndAbort(); |
342 } | 348 } |
343 | 349 |
344 } // namespace media | 350 } // namespace media |
OLD | NEW |