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