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