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 <stddef.h> | 5 #include <stddef.h> |
6 #include <utility> | 6 #include <utility> |
7 #include <vector> | 7 #include <vector> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/macros.h" | 10 #include "base/macros.h" |
(...skipping 24 matching lines...) Expand all Loading... |
35 return arg.is_encrypted(); | 35 return arg.is_encrypted(); |
36 } | 36 } |
37 MATCHER(ClearConfig, "") { | 37 MATCHER(ClearConfig, "") { |
38 return !arg.is_encrypted(); | 38 return !arg.is_encrypted(); |
39 } | 39 } |
40 | 40 |
41 } // namespace | 41 } // namespace |
42 | 42 |
43 namespace media { | 43 namespace media { |
44 | 44 |
| 45 const char kDecoder1[] = "Decoder1"; |
| 46 const char kDecoder2[] = "Decoder2"; |
| 47 |
45 class AudioDecoderSelectorTest : public ::testing::Test { | 48 class AudioDecoderSelectorTest : public ::testing::Test { |
46 public: | 49 public: |
47 enum DecryptorCapability { | 50 enum DecryptorCapability { |
48 kNoCdm, // No CDM. Only possible for clear stream. | 51 kNoCdm, // No CDM. Only possible for clear stream. |
49 kNoDecryptor, // CDM is available but Decryptor is not supported. | 52 kNoDecryptor, // CDM is available but Decryptor is not supported. |
50 kDecryptOnly, | 53 kDecryptOnly, |
51 kDecryptAndDecode | 54 kDecryptAndDecode |
52 }; | 55 }; |
53 | 56 |
54 AudioDecoderSelectorTest() | 57 AudioDecoderSelectorTest() |
55 : traits_(&media_log_), | 58 : traits_(&media_log_), |
56 demuxer_stream_( | 59 demuxer_stream_( |
57 new StrictMock<MockDemuxerStream>(DemuxerStream::AUDIO)), | 60 new StrictMock<MockDemuxerStream>(DemuxerStream::AUDIO)), |
58 decoder_1_(new StrictMock<MockAudioDecoder>()), | 61 decoder_1_(new StrictMock<MockAudioDecoder>(kDecoder1)), |
59 decoder_2_(new StrictMock<MockAudioDecoder>()) { | 62 decoder_2_(new StrictMock<MockAudioDecoder>(kDecoder2)) { |
60 all_decoders_.push_back(decoder_1_); | 63 all_decoders_.push_back(decoder_1_); |
61 all_decoders_.push_back(decoder_2_); | 64 all_decoders_.push_back(decoder_2_); |
62 // |cdm_context_| and |decryptor_| are conditionally created in | 65 // |cdm_context_| and |decryptor_| are conditionally created in |
63 // InitializeDecoderSelector(). | 66 // InitializeDecoderSelector(). |
64 } | 67 } |
65 | 68 |
66 ~AudioDecoderSelectorTest() { base::RunLoop().RunUntilIdle(); } | 69 ~AudioDecoderSelectorTest() { base::RunLoop().RunUntilIdle(); } |
67 | 70 |
68 MOCK_METHOD2(OnDecoderSelected, | 71 MOCK_METHOD2(OnDecoderSelected, |
69 void(AudioDecoder*, DecryptingDemuxerStream*)); | 72 void(AudioDecoder*, DecryptingDemuxerStream*)); |
(...skipping 11 matching lines...) Expand all Loading... |
81 demuxer_stream_->set_audio_decoder_config(clear_audio_config); | 84 demuxer_stream_->set_audio_decoder_config(clear_audio_config); |
82 } | 85 } |
83 | 86 |
84 void UseEncryptedStream() { | 87 void UseEncryptedStream() { |
85 AudioDecoderConfig encrypted_audio_config( | 88 AudioDecoderConfig encrypted_audio_config( |
86 kCodecVorbis, kSampleFormatPlanarF32, CHANNEL_LAYOUT_STEREO, 44100, | 89 kCodecVorbis, kSampleFormatPlanarF32, CHANNEL_LAYOUT_STEREO, 44100, |
87 EmptyExtraData(), AesCtrEncryptionScheme()); | 90 EmptyExtraData(), AesCtrEncryptionScheme()); |
88 demuxer_stream_->set_audio_decoder_config(encrypted_audio_config); | 91 demuxer_stream_->set_audio_decoder_config(encrypted_audio_config); |
89 } | 92 } |
90 | 93 |
| 94 ScopedVector<AudioDecoder> CreateVideoDecodersForTest() { |
| 95 return std::move(all_decoders_); |
| 96 } |
| 97 |
91 void InitializeDecoderSelector(DecryptorCapability decryptor_capability, | 98 void InitializeDecoderSelector(DecryptorCapability decryptor_capability, |
92 int num_decoders) { | 99 int num_decoders) { |
93 if (decryptor_capability != kNoCdm) { | 100 if (decryptor_capability != kNoCdm) { |
94 cdm_context_.reset(new StrictMock<MockCdmContext>()); | 101 cdm_context_.reset(new StrictMock<MockCdmContext>()); |
95 | 102 |
96 if (decryptor_capability == kNoDecryptor) { | 103 if (decryptor_capability == kNoDecryptor) { |
97 EXPECT_CALL(*cdm_context_, GetDecryptor()) | 104 EXPECT_CALL(*cdm_context_, GetDecryptor()) |
98 .WillRepeatedly(Return(nullptr)); | 105 .WillRepeatedly(Return(nullptr)); |
99 } else { | 106 } else { |
100 decryptor_.reset(new NiceMock<MockDecryptor>()); | 107 decryptor_.reset(new NiceMock<MockDecryptor>()); |
101 EXPECT_CALL(*cdm_context_, GetDecryptor()) | 108 EXPECT_CALL(*cdm_context_, GetDecryptor()) |
102 .WillRepeatedly(Return(decryptor_.get())); | 109 .WillRepeatedly(Return(decryptor_.get())); |
103 EXPECT_CALL(*decryptor_, InitializeAudioDecoder(_, _)) | 110 EXPECT_CALL(*decryptor_, InitializeAudioDecoder(_, _)) |
104 .WillRepeatedly( | 111 .WillRepeatedly( |
105 RunCallback<1>(decryptor_capability == kDecryptAndDecode)); | 112 RunCallback<1>(decryptor_capability == kDecryptAndDecode)); |
106 } | 113 } |
107 } | 114 } |
108 | 115 |
109 DCHECK_GE(all_decoders_.size(), static_cast<size_t>(num_decoders)); | 116 DCHECK_GE(all_decoders_.size(), static_cast<size_t>(num_decoders)); |
110 all_decoders_.erase( | 117 all_decoders_.erase( |
111 all_decoders_.begin() + num_decoders, all_decoders_.end()); | 118 all_decoders_.begin() + num_decoders, all_decoders_.end()); |
112 | 119 |
113 decoder_selector_.reset(new AudioDecoderSelector( | 120 decoder_selector_.reset(new AudioDecoderSelector( |
114 message_loop_.task_runner(), std::move(all_decoders_), &media_log_)); | 121 message_loop_.task_runner(), |
| 122 base::Bind(&AudioDecoderSelectorTest::CreateVideoDecodersForTest, |
| 123 base::Unretained(this)), |
| 124 &media_log_)); |
115 } | 125 } |
116 | 126 |
117 void SelectDecoder() { | 127 void SelectDecoderWithBlacklist(const std::string& blacklisted_decoder) { |
118 decoder_selector_->SelectDecoder( | 128 decoder_selector_->SelectDecoder( |
119 &traits_, demuxer_stream_.get(), cdm_context_.get(), | 129 &traits_, demuxer_stream_.get(), cdm_context_.get(), |
| 130 blacklisted_decoder, |
120 base::Bind(&AudioDecoderSelectorTest::MockOnDecoderSelected, | 131 base::Bind(&AudioDecoderSelectorTest::MockOnDecoderSelected, |
121 base::Unretained(this)), | 132 base::Unretained(this)), |
122 base::Bind(&AudioDecoderSelectorTest::OnDecoderOutput), | 133 base::Bind(&AudioDecoderSelectorTest::OnDecoderOutput), |
123 base::Bind(&AudioDecoderSelectorTest::OnWaitingForDecryptionKey)); | 134 base::Bind(&AudioDecoderSelectorTest::OnWaitingForDecryptionKey)); |
124 base::RunLoop().RunUntilIdle(); | 135 base::RunLoop().RunUntilIdle(); |
125 } | 136 } |
126 | 137 |
| 138 void SelectDecoder() { SelectDecoderWithBlacklist(""); } |
| 139 |
127 void SelectDecoderAndDestroy() { | 140 void SelectDecoderAndDestroy() { |
128 SelectDecoder(); | 141 SelectDecoder(); |
129 | 142 |
130 EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull())); | 143 EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull())); |
131 decoder_selector_.reset(); | 144 decoder_selector_.reset(); |
132 base::RunLoop().RunUntilIdle(); | 145 base::RunLoop().RunUntilIdle(); |
133 } | 146 } |
134 | 147 |
135 static void OnDecoderOutput(const scoped_refptr<AudioBuffer>& output) { | 148 static void OnDecoderOutput(const scoped_refptr<AudioBuffer>& output) { |
136 NOTREACHED(); | 149 NOTREACHED(); |
(...skipping 24 matching lines...) Expand all Loading... |
161 StrictMock<MockAudioDecoder>* decoder_2_; | 174 StrictMock<MockAudioDecoder>* decoder_2_; |
162 ScopedVector<AudioDecoder> all_decoders_; | 175 ScopedVector<AudioDecoder> all_decoders_; |
163 std::unique_ptr<AudioDecoder> selected_decoder_; | 176 std::unique_ptr<AudioDecoder> selected_decoder_; |
164 | 177 |
165 base::MessageLoop message_loop_; | 178 base::MessageLoop message_loop_; |
166 | 179 |
167 private: | 180 private: |
168 DISALLOW_COPY_AND_ASSIGN(AudioDecoderSelectorTest); | 181 DISALLOW_COPY_AND_ASSIGN(AudioDecoderSelectorTest); |
169 }; | 182 }; |
170 | 183 |
171 // Tests for clear streams. | 184 // Tests for clear streams. The CDM will not be used for clear streams so |
| 185 // DecryptorCapability doesn't really matter. |
172 | 186 |
173 TEST_F(AudioDecoderSelectorTest, ClearStream_NoDecryptor_NoClearDecoder) { | 187 TEST_F(AudioDecoderSelectorTest, ClearStream_NoClearDecoder) { |
174 UseClearStream(); | 188 UseClearStream(); |
175 InitializeDecoderSelector(kNoDecryptor, 0); | 189 |
| 190 // DecoderSelector will not try decrypting decoders for clear stream, even |
| 191 // if the CDM is capable of doing decrypt and decode. |
| 192 InitializeDecoderSelector(kDecryptAndDecode, 0); |
176 | 193 |
177 EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull())); | 194 EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull())); |
178 | 195 |
179 SelectDecoder(); | 196 SelectDecoder(); |
180 } | 197 } |
181 | 198 |
182 TEST_F(AudioDecoderSelectorTest, ClearStream_NoCdm_OneClearDecoder) { | 199 TEST_F(AudioDecoderSelectorTest, ClearStream_OneClearDecoder) { |
183 UseClearStream(); | 200 UseClearStream(); |
184 InitializeDecoderSelector(kNoCdm, 1); | 201 InitializeDecoderSelector(kNoCdm, 1); |
185 | 202 |
186 EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _)) | 203 EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _)) |
187 .WillOnce(RunCallback<2>(true)); | 204 .WillOnce(RunCallback<2>(true)); |
188 EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull())); | 205 EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull())); |
189 | 206 |
190 SelectDecoder(); | 207 SelectDecoder(); |
191 } | 208 } |
192 | 209 |
193 TEST_F(AudioDecoderSelectorTest, Destroy_ClearStream_NoCdm_OneClearDecoder) { | 210 TEST_F(AudioDecoderSelectorTest, Destroy_ClearStream_OneClearDecoder) { |
194 UseClearStream(); | 211 UseClearStream(); |
195 InitializeDecoderSelector(kNoCdm, 1); | 212 InitializeDecoderSelector(kNoCdm, 1); |
196 | 213 |
197 EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _)); | 214 EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _)); |
198 | 215 |
199 SelectDecoderAndDestroy(); | 216 SelectDecoderAndDestroy(); |
200 } | 217 } |
201 | 218 |
202 TEST_F(AudioDecoderSelectorTest, ClearStream_NoCdm_MultipleClearDecoder) { | 219 TEST_F(AudioDecoderSelectorTest, ClearStream_MultipleClearDecoder) { |
203 UseClearStream(); | 220 UseClearStream(); |
204 InitializeDecoderSelector(kNoCdm, 2); | 221 InitializeDecoderSelector(kNoCdm, 2); |
205 | 222 |
206 EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _)) | 223 EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _)) |
207 .WillOnce(RunCallback<2>(false)); | 224 .WillOnce(RunCallback<2>(false)); |
208 EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _)) | 225 EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _)) |
209 .WillOnce(RunCallback<2>(true)); | 226 .WillOnce(RunCallback<2>(true)); |
210 EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, IsNull())); | 227 EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, IsNull())); |
211 | 228 |
212 SelectDecoder(); | 229 SelectDecoder(); |
213 } | 230 } |
214 | 231 |
215 TEST_F(AudioDecoderSelectorTest, | 232 TEST_F(AudioDecoderSelectorTest, Destroy_ClearStream_MultipleClearDecoder) { |
216 Destroy_ClearStream_NoCdm_MultipleClearDecoder) { | |
217 UseClearStream(); | 233 UseClearStream(); |
218 InitializeDecoderSelector(kNoCdm, 2); | 234 InitializeDecoderSelector(kNoCdm, 2); |
219 | 235 |
220 EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _)) | 236 EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _)) |
221 .WillOnce(RunCallback<2>(false)); | 237 .WillOnce(RunCallback<2>(false)); |
222 EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _)); | 238 EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _)); |
223 | 239 |
224 SelectDecoderAndDestroy(); | 240 SelectDecoderAndDestroy(); |
225 } | 241 } |
226 | 242 |
227 TEST_F(AudioDecoderSelectorTest, ClearStream_NoDecryptor_OneClearDecoder) { | 243 TEST_F(AudioDecoderSelectorTest, ClearStream_BlackListedDecoder) { |
228 UseClearStream(); | 244 UseClearStream(); |
229 InitializeDecoderSelector(kNoDecryptor, 1); | 245 InitializeDecoderSelector(kNoCdm, 2); |
230 | 246 |
231 EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _)) | 247 // Decoder 1 is blacklisted and will not even be tried. |
232 .WillOnce(RunCallback<2>(false)); | 248 EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _)) |
233 EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull())); | |
234 | |
235 SelectDecoder(); | |
236 } | |
237 | |
238 TEST_F(AudioDecoderSelectorTest, | |
239 Destroy_ClearStream_NoDecryptor_OneClearDecoder) { | |
240 UseClearStream(); | |
241 InitializeDecoderSelector(kNoDecryptor, 1); | |
242 | |
243 EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _)); | |
244 | |
245 SelectDecoderAndDestroy(); | |
246 } | |
247 | |
248 TEST_F(AudioDecoderSelectorTest, ClearStream_NoDecryptor_MultipleClearDecoder) { | |
249 UseClearStream(); | |
250 InitializeDecoderSelector(kNoDecryptor, 2); | |
251 | |
252 EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _)) | |
253 .WillOnce(RunCallback<2>(false)); | |
254 EXPECT_CALL(*decoder_2_, Initialize(EncryptedConfig(), _, _, _)) | |
255 .WillOnce(RunCallback<2>(true)); | 249 .WillOnce(RunCallback<2>(true)); |
256 EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, IsNull())); | 250 EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, IsNull())); |
257 | 251 |
258 SelectDecoder(); | 252 SelectDecoderWithBlacklist(kDecoder1); |
259 } | |
260 | |
261 TEST_F(AudioDecoderSelectorTest, | |
262 Destroy_ClearStream_NoDecryptor_MultipleClearDecoder) { | |
263 UseClearStream(); | |
264 InitializeDecoderSelector(kNoDecryptor, 2); | |
265 | |
266 EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _)) | |
267 .WillOnce(RunCallback<2>(false)); | |
268 EXPECT_CALL(*decoder_2_, Initialize(EncryptedConfig(), _, _, _)); | |
269 | |
270 SelectDecoderAndDestroy(); | |
271 } | |
272 | |
273 TEST_F(AudioDecoderSelectorTest, ClearStream_DecryptOnly) { | |
274 UseClearStream(); | |
275 InitializeDecoderSelector(kDecryptOnly, 1); | |
276 | |
277 EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _)) | |
278 .WillOnce(RunCallback<2>(true)); | |
279 EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, NotNull())); | |
280 | |
281 SelectDecoder(); | |
282 } | |
283 | |
284 TEST_F(AudioDecoderSelectorTest, Destroy_ClearStream_DecryptOnly) { | |
285 UseClearStream(); | |
286 InitializeDecoderSelector(kDecryptOnly, 1); | |
287 | |
288 EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _)); | |
289 | |
290 SelectDecoderAndDestroy(); | |
291 } | |
292 | |
293 TEST_F(AudioDecoderSelectorTest, ClearStream_DecryptAndDecode) { | |
294 UseClearStream(); | |
295 InitializeDecoderSelector(kDecryptAndDecode, 1); | |
296 | |
297 #if !defined(OS_ANDROID) | |
298 // A DecryptingVideoDecoder will be created and selected. The clear decoder | |
299 // should not be touched at all. No DecryptingDemuxerStream should be | |
300 // created. | |
301 EXPECT_CALL(*this, OnDecoderSelected(NotNull(), IsNull())); | |
302 #else | |
303 // A DecryptingDemuxerStream will be created. The clear decoder will be | |
304 // initialized and returned. | |
305 EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _)) | |
306 .WillOnce(RunCallback<2>(true)); | |
307 EXPECT_CALL(*this, OnDecoderSelected(NotNull(), NotNull())); | |
308 #endif | |
309 | |
310 SelectDecoder(); | |
311 } | 253 } |
312 | 254 |
313 // Tests for encrypted streams. | 255 // Tests for encrypted streams. |
314 | 256 |
315 TEST_F(AudioDecoderSelectorTest, EncryptedStream_NoDecryptor_OneClearDecoder) { | 257 TEST_F(AudioDecoderSelectorTest, EncryptedStream_NoDecryptor_OneClearDecoder) { |
316 UseEncryptedStream(); | 258 UseEncryptedStream(); |
317 InitializeDecoderSelector(kNoDecryptor, 1); | 259 InitializeDecoderSelector(kNoDecryptor, 1); |
318 | 260 |
319 EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _)) | 261 EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _)) |
320 .WillOnce(RunCallback<2>(false)); | 262 .WillOnce(RunCallback<2>(false)); |
(...skipping 106 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
427 // A DecryptingDemuxerStream will be created. The clear decoder will be | 369 // A DecryptingDemuxerStream will be created. The clear decoder will be |
428 // initialized and returned. | 370 // initialized and returned. |
429 EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _)) | 371 EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _)) |
430 .WillOnce(RunCallback<2>(true)); | 372 .WillOnce(RunCallback<2>(true)); |
431 EXPECT_CALL(*this, OnDecoderSelected(NotNull(), NotNull())); | 373 EXPECT_CALL(*this, OnDecoderSelected(NotNull(), NotNull())); |
432 #endif | 374 #endif |
433 | 375 |
434 SelectDecoder(); | 376 SelectDecoder(); |
435 } | 377 } |
436 | 378 |
| 379 TEST_F(AudioDecoderSelectorTest, |
| 380 EncryptedStream_NoDecryptor_BlackListedDecoder) { |
| 381 UseEncryptedStream(); |
| 382 InitializeDecoderSelector(kNoDecryptor, 2); |
| 383 |
| 384 EXPECT_CALL(*decoder_2_, Initialize(EncryptedConfig(), _, _, _)) |
| 385 .WillOnce(RunCallback<2>(true)); |
| 386 EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, IsNull())); |
| 387 |
| 388 SelectDecoderWithBlacklist(kDecoder1); |
| 389 } |
| 390 |
| 391 TEST_F(AudioDecoderSelectorTest, |
| 392 EncryptedStream_DecryptOnly_BlackListedDecoder) { |
| 393 UseEncryptedStream(); |
| 394 InitializeDecoderSelector(kDecryptOnly, 2); |
| 395 |
| 396 // When DecryptingDemuxerStream is chosen, the blacklist is ignored. |
| 397 EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _)) |
| 398 .WillOnce(RunCallback<2>(false)); |
| 399 EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _)) |
| 400 .WillOnce(RunCallback<2>(true)); |
| 401 EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, NotNull())); |
| 402 |
| 403 SelectDecoderWithBlacklist(kDecoder2); |
| 404 } |
| 405 |
| 406 TEST_F(AudioDecoderSelectorTest, |
| 407 EncryptedStream_DecryptAndDecode_BlackListedDecoder) { |
| 408 UseEncryptedStream(); |
| 409 InitializeDecoderSelector(kDecryptAndDecode, 2); |
| 410 |
| 411 // DecryptingAudioDecoder is blacklisted so we'll fall back to use |
| 412 // DecryptingDemuxerStream to do decrypt-only. |
| 413 EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _)) |
| 414 .WillOnce(RunCallback<2>(false)); |
| 415 EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _)) |
| 416 .WillOnce(RunCallback<2>(true)); |
| 417 EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, NotNull())); |
| 418 |
| 419 // TODO(xhwang): Avoid the hardcoded string here. |
| 420 SelectDecoderWithBlacklist("DecryptingAudioDecoder"); |
| 421 } |
| 422 |
437 } // namespace media | 423 } // namespace media |
OLD | NEW |