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 3// found in the LICENSE file. 4 5#include <vector> 6 7#include "base/bind.h" 8#include "base/message_loop/message_loop.h" 9#include "media/base/gmock_callback_support.h" 10#include "media/base/mock_filters.h" 11#include "media/base/test_helpers.h" 12#include "media/filters/decoder_selector.h" 13#include "media/filters/decrypting_demuxer_stream.h" 14#include "testing/gtest/include/gtest/gtest.h" 15 16using ::testing::_; 17using ::testing::IsNull; 18using ::testing::NiceMock; 19using ::testing::NotNull; 20using ::testing::Return; 21using ::testing::StrictMock; 22 23namespace media { 24 25class VideoDecoderSelectorTest : public ::testing::Test { 26 public: 27 enum DecryptorCapability { 28 kNoDecryptor, 29 // Used to test Abort() during DecryptingVideoDecoder::Initialize() and 30 // DecryptingDemuxerStream::Initialize(). We don't need this for normal 31 // VideoDecoders since we use MockVideoDecoder. 32 kHoldSetDecryptor, 33 kDecryptOnly, 34 kDecryptAndDecode 35 }; 36 37 VideoDecoderSelectorTest() 38 : demuxer_stream_( 39 new StrictMock<MockDemuxerStream>(DemuxerStream::VIDEO)), 40 decryptor_(new NiceMock<MockDecryptor>()), 41 decoder_1_(new StrictMock<MockVideoDecoder>()), 42 decoder_2_(new StrictMock<MockVideoDecoder>()) { 43 all_decoders_.push_back(decoder_1_); 44 all_decoders_.push_back(decoder_2_); 45 } 46 47 ~VideoDecoderSelectorTest() { 48 if (selected_decoder_) 49 selected_decoder_->Stop(); 50 51 message_loop_.RunUntilIdle(); 52 } 53 54 MOCK_METHOD1(SetDecryptorReadyCallback, void(const media::DecryptorReadyCB&)); 55 MOCK_METHOD2(OnDecoderSelected, 56 void(VideoDecoder*, DecryptingDemuxerStream*)); 57 58 void MockOnDecoderSelected( 59 scoped_ptr<VideoDecoder> decoder, 60 scoped_ptr<DecryptingDemuxerStream> stream) { 61 OnDecoderSelected(decoder.get(), stream.get()); 62 selected_decoder_ = decoder.Pass(); 63 } 64 65 void UseClearStream() { 66 demuxer_stream_->set_video_decoder_config(TestVideoConfig::Normal()); 67 } 68 69 void UseEncryptedStream() { 70 demuxer_stream_->set_video_decoder_config( 71 TestVideoConfig::NormalEncrypted()); 72 } 73 74 void InitializeDecoderSelector(DecryptorCapability decryptor_capability, 75 int num_decoders) { 76 SetDecryptorReadyCB set_decryptor_ready_cb; 77 if (decryptor_capability != kNoDecryptor) { 78 set_decryptor_ready_cb = 79 base::Bind(&VideoDecoderSelectorTest::SetDecryptorReadyCallback, 80 base::Unretained(this)); 81 } 82 83 if (decryptor_capability == kDecryptOnly || 84 decryptor_capability == kDecryptAndDecode) { 85 EXPECT_CALL(*this, SetDecryptorReadyCallback(_)) 86 .WillRepeatedly(RunCallback<0>(decryptor_.get())); 87 88 if (decryptor_capability == kDecryptOnly) { 89 EXPECT_CALL(*decryptor_, InitializeVideoDecoder(_, _)) 90 .WillRepeatedly(RunCallback<1>(false)); 91 } else { 92 EXPECT_CALL(*decryptor_, InitializeVideoDecoder(_, _)) 93 .WillRepeatedly(RunCallback<1>(true)); 94 } 95 } else if (decryptor_capability == kHoldSetDecryptor) { 96 // Set and cancel DecryptorReadyCB but the callback is never fired. 97 EXPECT_CALL(*this, SetDecryptorReadyCallback(_)) 98 .Times(2); 99 } 100 101 DCHECK_GE(all_decoders_.size(), static_cast<size_t>(num_decoders)); 102 all_decoders_.erase( 103 all_decoders_.begin() + num_decoders, all_decoders_.end()); 104 105 decoder_selector_.reset(new VideoDecoderSelector( 106 message_loop_.message_loop_proxy(), 107 all_decoders_.Pass(), 108 set_decryptor_ready_cb)); 109 } 110 111 void SelectDecoder() { 112 decoder_selector_->SelectDecoder( 113 demuxer_stream_.get(), 114 false, 115 base::Bind(&VideoDecoderSelectorTest::MockOnDecoderSelected, 116 base::Unretained(this)), 117 base::Bind(&VideoDecoderSelectorTest::FrameReady, 118 base::Unretained(this))); 119 message_loop_.RunUntilIdle(); 120 } 121 122 void SelectDecoderAndAbort() { 123 SelectDecoder(); 124 125 EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull())); 126 decoder_selector_->Abort(); 127 message_loop_.RunUntilIdle(); 128 } 129 130 void FrameReady(const scoped_refptr<VideoFrame>& frame) { 131 NOTREACHED(); 132 } 133 134 // Fixture members. 135 scoped_ptr<VideoDecoderSelector> decoder_selector_; 136 scoped_ptr<StrictMock<MockDemuxerStream> > demuxer_stream_; 137 // Use NiceMock since we don't care about most of calls on the decryptor, e.g. 138 // RegisterNewKeyCB(). 139 scoped_ptr<NiceMock<MockDecryptor> > decryptor_; 140 StrictMock<MockVideoDecoder>* decoder_1_; 141 StrictMock<MockVideoDecoder>* decoder_2_; 142 ScopedVector<VideoDecoder> all_decoders_; 143 144 scoped_ptr<VideoDecoder> selected_decoder_; 145 146 base::MessageLoop message_loop_; 147 148 private: 149 DISALLOW_COPY_AND_ASSIGN(VideoDecoderSelectorTest); 150}; 151 152// Note: 153// In all the tests, Stop() is expected to be called on a decoder if a decoder: 154// - is pending initialization and DecoderSelector::Abort() is called, or 155// - has been successfully initialized. 156 157// The stream is not encrypted but we have no clear decoder. No decoder can be 158// selected. 159TEST_F(VideoDecoderSelectorTest, ClearStream_NoDecryptor_NoClearDecoder) { 160 UseClearStream(); 161 InitializeDecoderSelector(kNoDecryptor, 0); 162 163 EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull())); 164 165 SelectDecoder(); 166} 167 168// The stream is not encrypted and we have one clear decoder. The decoder 169// will be selected. 170TEST_F(VideoDecoderSelectorTest, ClearStream_NoDecryptor_OneClearDecoder) { 171 UseClearStream(); 172 InitializeDecoderSelector(kNoDecryptor, 1); 173 174 EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _)) 175 .WillOnce(RunCallback<2>(PIPELINE_OK)); 176 EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull())); 177 EXPECT_CALL(*decoder_1_, Stop()); 178 179 SelectDecoder(); 180} 181 182TEST_F(VideoDecoderSelectorTest, 183 Abort_ClearStream_NoDecryptor_OneClearDecoder) { 184 UseClearStream(); 185 InitializeDecoderSelector(kNoDecryptor, 1); 186 187 EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _)); 188 EXPECT_CALL(*decoder_1_, Stop()); 189 190 SelectDecoderAndAbort(); 191} 192 193// The stream is not encrypted and we have multiple clear decoders. The first 194// decoder that can decode the input stream will be selected. 195TEST_F(VideoDecoderSelectorTest, ClearStream_NoDecryptor_MultipleClearDecoder) { 196 UseClearStream(); 197 InitializeDecoderSelector(kNoDecryptor, 2); 198 199 EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _)) 200 .WillOnce(RunCallback<2>(DECODER_ERROR_NOT_SUPPORTED)); 201 EXPECT_CALL(*decoder_2_, Initialize(_, _, _, _)) 202 .WillOnce(RunCallback<2>(PIPELINE_OK)); 203 EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, IsNull())); 204 EXPECT_CALL(*decoder_2_, Stop()); 205 206 SelectDecoder(); 207} 208 209TEST_F(VideoDecoderSelectorTest, 210 Abort_ClearStream_NoDecryptor_MultipleClearDecoder) { 211 UseClearStream(); 212 InitializeDecoderSelector(kNoDecryptor, 2); 213 214 EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _)) 215 .WillOnce(RunCallback<2>(DECODER_ERROR_NOT_SUPPORTED)); 216 EXPECT_CALL(*decoder_2_, Initialize(_, _, _, _)); 217 EXPECT_CALL(*decoder_2_, Stop()); 218 219 SelectDecoderAndAbort(); 220} 221 222// There is a decryptor but the stream is not encrypted. The decoder will be 223// selected. 224TEST_F(VideoDecoderSelectorTest, ClearStream_HasDecryptor) { 225 UseClearStream(); 226 InitializeDecoderSelector(kDecryptOnly, 1); 227 228 EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _)) 229 .WillOnce(RunCallback<2>(PIPELINE_OK)); 230 EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull())); 231 EXPECT_CALL(*decoder_1_, Stop()); 232 233 SelectDecoder(); 234} 235 236TEST_F(VideoDecoderSelectorTest, Abort_ClearStream_HasDecryptor) { 237 UseClearStream(); 238 InitializeDecoderSelector(kDecryptOnly, 1); 239 240 EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _)); 241 EXPECT_CALL(*decoder_1_, Stop()); 242 243 SelectDecoderAndAbort(); 244} 245 246// The stream is encrypted and there's no decryptor. No decoder can be selected. 247TEST_F(VideoDecoderSelectorTest, EncryptedStream_NoDecryptor) { 248 UseEncryptedStream(); 249 InitializeDecoderSelector(kNoDecryptor, 1); 250 251 EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull())); 252 253 SelectDecoder(); 254} 255 256// Decryptor can only do decryption and there's no decoder available. No decoder 257// can be selected. 258TEST_F(VideoDecoderSelectorTest, EncryptedStream_DecryptOnly_NoClearDecoder) { 259 UseEncryptedStream(); 260 InitializeDecoderSelector(kDecryptOnly, 0); 261 262 EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull())); 263 264 SelectDecoder(); 265} 266 267TEST_F(VideoDecoderSelectorTest, 268 Abort_EncryptedStream_DecryptOnly_NoClearDecoder) { 269 UseEncryptedStream(); 270 InitializeDecoderSelector(kHoldSetDecryptor, 0); 271 272 SelectDecoderAndAbort(); 273} 274 275// Decryptor can do decryption-only and there's a decoder available. The decoder 276// will be selected and a DecryptingDemuxerStream will be created. 277TEST_F(VideoDecoderSelectorTest, EncryptedStream_DecryptOnly_OneClearDecoder) { 278 UseEncryptedStream(); 279 InitializeDecoderSelector(kDecryptOnly, 1); 280 281 EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _)) 282 .WillOnce(RunCallback<2>(PIPELINE_OK)); 283 EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, NotNull())); 284 EXPECT_CALL(*decoder_1_, Stop()); 285 286 SelectDecoder(); 287} 288 289TEST_F(VideoDecoderSelectorTest, 290 Abort_EncryptedStream_DecryptOnly_OneClearDecoder) { 291 UseEncryptedStream(); 292 InitializeDecoderSelector(kDecryptOnly, 1); 293 294 EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _)); 295 EXPECT_CALL(*decoder_1_, Stop()); 296 297 SelectDecoderAndAbort(); 298} 299 300// Decryptor can only do decryption and there are multiple decoders available. 301// The first decoder that can decode the input stream will be selected and 302// a DecryptingDemuxerStream will be created. 303TEST_F(VideoDecoderSelectorTest, 304 EncryptedStream_DecryptOnly_MultipleClearDecoder) { 305 UseEncryptedStream(); 306 InitializeDecoderSelector(kDecryptOnly, 2); 307 308 EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _)) 309 .WillOnce(RunCallback<2>(DECODER_ERROR_NOT_SUPPORTED)); 310 EXPECT_CALL(*decoder_2_, Initialize(_, _, _, _)) 311 .WillOnce(RunCallback<2>(PIPELINE_OK)); 312 EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, NotNull())); 313 EXPECT_CALL(*decoder_2_, Stop()); 314 315 SelectDecoder(); 316} 317 318TEST_F(VideoDecoderSelectorTest, 319 Abort_EncryptedStream_DecryptOnly_MultipleClearDecoder) { 320 UseEncryptedStream(); 321 InitializeDecoderSelector(kDecryptOnly, 2); 322 323 EXPECT_CALL(*decoder_1_, Initialize(_, _, _, _)) 324 .WillOnce(RunCallback<2>(DECODER_ERROR_NOT_SUPPORTED)); 325 EXPECT_CALL(*decoder_2_, Initialize(_, _, _, _)); 326 EXPECT_CALL(*decoder_2_, Stop()); 327 328 SelectDecoderAndAbort(); 329} 330 331// Decryptor can do decryption and decoding. A DecryptingVideoDecoder will be 332// created and selected. The clear decoders should not be touched at all. 333// No DecryptingDemuxerStream should to be created. 334TEST_F(VideoDecoderSelectorTest, EncryptedStream_DecryptAndDecode) { 335 UseEncryptedStream(); 336 InitializeDecoderSelector(kDecryptAndDecode, 1); 337 338 EXPECT_CALL(*this, OnDecoderSelected(NotNull(), IsNull())); 339 340 SelectDecoder(); 341} 342 343TEST_F(VideoDecoderSelectorTest, Abort_EncryptedStream_DecryptAndDecode) { 344 UseEncryptedStream(); 345 InitializeDecoderSelector(kHoldSetDecryptor, 1); 346 347 SelectDecoderAndAbort(); 348} 349 350} // namespace media 351