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