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 "base/stl_util.h" | 9 #include "base/stl_util.h" |
10 #include "base/test/simple_test_tick_clock.h" | 10 #include "base/test/simple_test_tick_clock.h" |
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
80 // is executed on |message_loop_| and the mock filters instantly call | 80 // is executed on |message_loop_| and the mock filters instantly call |
81 // InitializationComplete(), which keeps the pipeline humming along. If | 81 // InitializationComplete(), which keeps the pipeline humming along. If |
82 // either filters don't call InitializationComplete() immediately or filter | 82 // either filters don't call InitializationComplete() immediately or filter |
83 // initialization is moved to a separate thread this test will become flaky. | 83 // initialization is moved to a separate thread this test will become flaky. |
84 class PipelineTest : public ::testing::Test { | 84 class PipelineTest : public ::testing::Test { |
85 public: | 85 public: |
86 PipelineTest() | 86 PipelineTest() |
87 : pipeline_(new Pipeline(message_loop_.message_loop_proxy(), | 87 : pipeline_(new Pipeline(message_loop_.message_loop_proxy(), |
88 new MediaLog())), | 88 new MediaLog())), |
89 filter_collection_(new FilterCollection()), | 89 filter_collection_(new FilterCollection()), |
90 demuxer_(new MockDemuxer()) { | 90 demuxer_(new StrictMock<MockDemuxer>()) { |
91 filter_collection_->SetDemuxer(demuxer_.get()); | 91 filter_collection_->SetDemuxer(demuxer_.get()); |
92 | 92 |
93 video_renderer_ = new MockVideoRenderer(); | 93 video_renderer_ = new StrictMock<MockVideoRenderer>(); |
94 scoped_ptr<VideoRenderer> video_renderer(video_renderer_); | 94 scoped_ptr<VideoRenderer> video_renderer(video_renderer_); |
95 filter_collection_->SetVideoRenderer(video_renderer.Pass()); | 95 filter_collection_->SetVideoRenderer(video_renderer.Pass()); |
96 | 96 |
97 audio_renderer_ = new MockAudioRenderer(); | 97 audio_renderer_ = new StrictMock<MockAudioRenderer>(); |
98 scoped_ptr<AudioRenderer> audio_renderer(audio_renderer_); | 98 scoped_ptr<AudioRenderer> audio_renderer(audio_renderer_); |
99 filter_collection_->SetAudioRenderer(audio_renderer.Pass()); | 99 filter_collection_->SetAudioRenderer(audio_renderer.Pass()); |
100 | 100 |
101 text_renderer_ = new TextRenderer( | 101 text_renderer_ = new TextRenderer( |
102 message_loop_.message_loop_proxy(), | 102 message_loop_.message_loop_proxy(), |
103 base::Bind(&PipelineTest::OnAddTextTrack, | 103 base::Bind(&PipelineTest::OnAddTextTrack, |
104 base::Unretained(this))); | 104 base::Unretained(this))); |
105 scoped_ptr<TextRenderer> text_renderer(text_renderer_); | 105 scoped_ptr<TextRenderer> text_renderer(text_renderer_); |
106 filter_collection_->SetTextRenderer(text_renderer.Pass()); | 106 filter_collection_->SetTextRenderer(text_renderer.Pass()); |
107 | 107 |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
196 // after tests have set expectations any filters they wish to use. | 196 // after tests have set expectations any filters they wish to use. |
197 void StartPipeline(PipelineStatus start_status) { | 197 void StartPipeline(PipelineStatus start_status) { |
198 EXPECT_CALL(callbacks_, OnStart(start_status)); | 198 EXPECT_CALL(callbacks_, OnStart(start_status)); |
199 | 199 |
200 if (start_status == PIPELINE_OK) { | 200 if (start_status == PIPELINE_OK) { |
201 EXPECT_CALL(callbacks_, OnMetadata(_)).WillOnce(SaveArg<0>(&metadata_)); | 201 EXPECT_CALL(callbacks_, OnMetadata(_)).WillOnce(SaveArg<0>(&metadata_)); |
202 | 202 |
203 if (audio_stream_) { | 203 if (audio_stream_) { |
204 EXPECT_CALL(*audio_renderer_, SetPlaybackRate(0.0f)); | 204 EXPECT_CALL(*audio_renderer_, SetPlaybackRate(0.0f)); |
205 EXPECT_CALL(*audio_renderer_, SetVolume(1.0f)); | 205 EXPECT_CALL(*audio_renderer_, SetVolume(1.0f)); |
206 EXPECT_CALL(*audio_renderer_, StartPlayingFrom(base::TimeDelta())) | 206 EXPECT_CALL(*audio_renderer_, SetMediaTime(base::TimeDelta())); |
| 207 EXPECT_CALL(*audio_renderer_, StartPlaying()) |
207 .WillOnce(SetBufferingState(&audio_buffering_state_cb_, | 208 .WillOnce(SetBufferingState(&audio_buffering_state_cb_, |
208 BUFFERING_HAVE_ENOUGH)); | 209 BUFFERING_HAVE_ENOUGH)); |
209 EXPECT_CALL(*audio_renderer_, StartRendering()); | 210 EXPECT_CALL(*audio_renderer_, StartRendering()); |
210 } | 211 } |
211 | 212 |
212 if (video_stream_) { | 213 if (video_stream_) { |
213 EXPECT_CALL(*video_renderer_, StartPlayingFrom(base::TimeDelta())) | 214 EXPECT_CALL(*video_renderer_, StartPlaying()) |
214 .WillOnce(SetBufferingState(&video_buffering_state_cb_, | 215 .WillOnce(SetBufferingState(&video_buffering_state_cb_, |
215 BUFFERING_HAVE_ENOUGH)); | 216 BUFFERING_HAVE_ENOUGH)); |
216 } | 217 } |
217 | 218 |
218 EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH)); | 219 EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH)); |
219 } | 220 } |
220 | 221 |
221 pipeline_->Start( | 222 pipeline_->Start( |
222 filter_collection_.Pass(), | 223 filter_collection_.Pass(), |
223 base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)), | 224 base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)), |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
263 EXPECT_CALL(*demuxer_, Seek(seek_time, _)) | 264 EXPECT_CALL(*demuxer_, Seek(seek_time, _)) |
264 .WillOnce(RunCallback<1>(PIPELINE_OK)); | 265 .WillOnce(RunCallback<1>(PIPELINE_OK)); |
265 | 266 |
266 if (audio_stream_) { | 267 if (audio_stream_) { |
267 if (!underflowed) | 268 if (!underflowed) |
268 EXPECT_CALL(*audio_renderer_, StopRendering()); | 269 EXPECT_CALL(*audio_renderer_, StopRendering()); |
269 EXPECT_CALL(*audio_renderer_, Flush(_)) | 270 EXPECT_CALL(*audio_renderer_, Flush(_)) |
270 .WillOnce(DoAll(SetBufferingState(&audio_buffering_state_cb_, | 271 .WillOnce(DoAll(SetBufferingState(&audio_buffering_state_cb_, |
271 BUFFERING_HAVE_NOTHING), | 272 BUFFERING_HAVE_NOTHING), |
272 RunClosure<0>())); | 273 RunClosure<0>())); |
273 EXPECT_CALL(*audio_renderer_, StartPlayingFrom(seek_time)) | 274 EXPECT_CALL(*audio_renderer_, SetMediaTime(seek_time)); |
| 275 EXPECT_CALL(*audio_renderer_, StartPlaying()) |
274 .WillOnce(SetBufferingState(&audio_buffering_state_cb_, | 276 .WillOnce(SetBufferingState(&audio_buffering_state_cb_, |
275 BUFFERING_HAVE_ENOUGH)); | 277 BUFFERING_HAVE_ENOUGH)); |
276 EXPECT_CALL(*audio_renderer_, SetPlaybackRate(_)); | 278 EXPECT_CALL(*audio_renderer_, SetPlaybackRate(_)); |
277 EXPECT_CALL(*audio_renderer_, SetVolume(_)); | 279 EXPECT_CALL(*audio_renderer_, SetVolume(_)); |
278 EXPECT_CALL(*audio_renderer_, StartRendering()); | 280 EXPECT_CALL(*audio_renderer_, StartRendering()); |
279 } | 281 } |
280 | 282 |
281 if (video_stream_) { | 283 if (video_stream_) { |
282 EXPECT_CALL(*video_renderer_, Flush(_)) | 284 EXPECT_CALL(*video_renderer_, Flush(_)) |
283 .WillOnce(DoAll(SetBufferingState(&video_buffering_state_cb_, | 285 .WillOnce(DoAll(SetBufferingState(&video_buffering_state_cb_, |
284 BUFFERING_HAVE_NOTHING), | 286 BUFFERING_HAVE_NOTHING), |
285 RunClosure<0>())); | 287 RunClosure<0>())); |
286 EXPECT_CALL(*video_renderer_, StartPlayingFrom(seek_time)) | 288 EXPECT_CALL(*video_renderer_, StartPlaying()) |
287 .WillOnce(SetBufferingState(&video_buffering_state_cb_, | 289 .WillOnce(SetBufferingState(&video_buffering_state_cb_, |
288 BUFFERING_HAVE_ENOUGH)); | 290 BUFFERING_HAVE_ENOUGH)); |
289 } | 291 } |
290 | 292 |
291 // We expect a successful seek callback followed by a buffering update. | 293 // We expect a successful seek callback followed by a buffering update. |
292 EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK)); | 294 EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK)); |
293 EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH)); | 295 EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH)); |
294 } | 296 } |
295 | 297 |
296 void DoSeek(const base::TimeDelta& seek_time) { | 298 void DoSeek(const base::TimeDelta& seek_time) { |
(...skipping 27 matching lines...) Expand all Loading... |
324 done_cb.Run(text_track.Pass()); | 326 done_cb.Run(text_track.Pass()); |
325 } | 327 } |
326 | 328 |
327 // Fixture members. | 329 // Fixture members. |
328 StrictMock<CallbackHelper> callbacks_; | 330 StrictMock<CallbackHelper> callbacks_; |
329 base::SimpleTestTickClock test_tick_clock_; | 331 base::SimpleTestTickClock test_tick_clock_; |
330 base::MessageLoop message_loop_; | 332 base::MessageLoop message_loop_; |
331 scoped_ptr<Pipeline> pipeline_; | 333 scoped_ptr<Pipeline> pipeline_; |
332 | 334 |
333 scoped_ptr<FilterCollection> filter_collection_; | 335 scoped_ptr<FilterCollection> filter_collection_; |
334 scoped_ptr<MockDemuxer> demuxer_; | 336 scoped_ptr<StrictMock<MockDemuxer>> demuxer_; |
335 MockVideoRenderer* video_renderer_; | 337 StrictMock<MockVideoRenderer>* video_renderer_; |
336 MockAudioRenderer* audio_renderer_; | 338 StrictMock<MockAudioRenderer>* audio_renderer_; |
337 StrictMock<CallbackHelper> text_renderer_callbacks_; | 339 StrictMock<CallbackHelper> text_renderer_callbacks_; |
338 TextRenderer* text_renderer_; | 340 TextRenderer* text_renderer_; |
339 scoped_ptr<StrictMock<MockDemuxerStream> > audio_stream_; | 341 scoped_ptr<StrictMock<MockDemuxerStream> > audio_stream_; |
340 scoped_ptr<StrictMock<MockDemuxerStream> > video_stream_; | 342 scoped_ptr<StrictMock<MockDemuxerStream> > video_stream_; |
341 scoped_ptr<FakeTextTrackStream> text_stream_; | 343 scoped_ptr<FakeTextTrackStream> text_stream_; |
342 AudioRenderer::TimeCB audio_time_cb_; | 344 AudioRenderer::TimeCB audio_time_cb_; |
343 BufferingStateCB audio_buffering_state_cb_; | 345 BufferingStateCB audio_buffering_state_cb_; |
344 BufferingStateCB video_buffering_state_cb_; | 346 BufferingStateCB video_buffering_state_cb_; |
345 base::Closure audio_ended_cb_; | 347 base::Closure audio_ended_cb_; |
346 base::Closure video_ended_cb_; | 348 base::Closure video_ended_cb_; |
(...skipping 439 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
786 base::Closure closure = base::Bind(&RunTimeCB, audio_time_cb_, 300, 700); | 788 base::Closure closure = base::Bind(&RunTimeCB, audio_time_cb_, 300, 700); |
787 EXPECT_CALL(*demuxer_, Seek(seek_time, _)) | 789 EXPECT_CALL(*demuxer_, Seek(seek_time, _)) |
788 .WillOnce(DoAll(InvokeWithoutArgs(&closure, &base::Closure::Run), | 790 .WillOnce(DoAll(InvokeWithoutArgs(&closure, &base::Closure::Run), |
789 RunCallback<1>(PIPELINE_OK))); | 791 RunCallback<1>(PIPELINE_OK))); |
790 | 792 |
791 EXPECT_CALL(*audio_renderer_, StopRendering()); | 793 EXPECT_CALL(*audio_renderer_, StopRendering()); |
792 EXPECT_CALL(*audio_renderer_, Flush(_)) | 794 EXPECT_CALL(*audio_renderer_, Flush(_)) |
793 .WillOnce(DoAll(SetBufferingState(&audio_buffering_state_cb_, | 795 .WillOnce(DoAll(SetBufferingState(&audio_buffering_state_cb_, |
794 BUFFERING_HAVE_NOTHING), | 796 BUFFERING_HAVE_NOTHING), |
795 RunClosure<0>())); | 797 RunClosure<0>())); |
796 EXPECT_CALL(*audio_renderer_, StartPlayingFrom(seek_time)) | 798 EXPECT_CALL(*audio_renderer_, SetMediaTime(seek_time)); |
| 799 EXPECT_CALL(*audio_renderer_, StartPlaying()) |
797 .WillOnce(SetBufferingState(&audio_buffering_state_cb_, | 800 .WillOnce(SetBufferingState(&audio_buffering_state_cb_, |
798 BUFFERING_HAVE_ENOUGH)); | 801 BUFFERING_HAVE_ENOUGH)); |
799 EXPECT_CALL(*audio_renderer_, SetPlaybackRate(_)); | 802 EXPECT_CALL(*audio_renderer_, SetPlaybackRate(_)); |
800 EXPECT_CALL(*audio_renderer_, SetVolume(_)); | 803 EXPECT_CALL(*audio_renderer_, SetVolume(_)); |
801 EXPECT_CALL(*audio_renderer_, StartRendering()); | 804 EXPECT_CALL(*audio_renderer_, StartRendering()); |
802 | 805 |
803 EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK)); | 806 EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK)); |
804 EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH)); | 807 EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH)); |
805 DoSeek(seek_time); | 808 DoSeek(seek_time); |
806 | 809 |
(...skipping 179 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
986 return status; | 989 return status; |
987 } | 990 } |
988 | 991 |
989 EXPECT_CALL(*video_renderer_, Initialize(_, _, _, _, _, _, _, _, _, _)) | 992 EXPECT_CALL(*video_renderer_, Initialize(_, _, _, _, _, _, _, _, _, _)) |
990 .WillOnce(DoAll(SaveArg<5>(&video_buffering_state_cb_), | 993 .WillOnce(DoAll(SaveArg<5>(&video_buffering_state_cb_), |
991 RunCallback<2>(PIPELINE_OK))); | 994 RunCallback<2>(PIPELINE_OK))); |
992 | 995 |
993 EXPECT_CALL(callbacks_, OnMetadata(_)); | 996 EXPECT_CALL(callbacks_, OnMetadata(_)); |
994 | 997 |
995 // If we get here it's a successful initialization. | 998 // If we get here it's a successful initialization. |
996 EXPECT_CALL(*audio_renderer_, StartPlayingFrom(base::TimeDelta())) | 999 EXPECT_CALL(*audio_renderer_, SetMediaTime(base::TimeDelta())); |
| 1000 EXPECT_CALL(*audio_renderer_, StartPlaying()) |
997 .WillOnce(SetBufferingState(&audio_buffering_state_cb_, | 1001 .WillOnce(SetBufferingState(&audio_buffering_state_cb_, |
998 BUFFERING_HAVE_ENOUGH)); | 1002 BUFFERING_HAVE_ENOUGH)); |
999 EXPECT_CALL(*video_renderer_, StartPlayingFrom(base::TimeDelta())) | 1003 EXPECT_CALL(*video_renderer_, StartPlaying()) |
1000 .WillOnce(SetBufferingState(&video_buffering_state_cb_, | 1004 .WillOnce(SetBufferingState(&video_buffering_state_cb_, |
1001 BUFFERING_HAVE_ENOUGH)); | 1005 BUFFERING_HAVE_ENOUGH)); |
1002 | 1006 |
1003 EXPECT_CALL(*audio_renderer_, SetPlaybackRate(0.0f)); | 1007 EXPECT_CALL(*audio_renderer_, SetPlaybackRate(0.0f)); |
1004 EXPECT_CALL(*audio_renderer_, SetVolume(1.0f)); | 1008 EXPECT_CALL(*audio_renderer_, SetVolume(1.0f)); |
1005 EXPECT_CALL(*audio_renderer_, StartRendering()); | 1009 EXPECT_CALL(*audio_renderer_, StartRendering()); |
1006 | 1010 |
1007 if (status == PIPELINE_OK) | 1011 if (status == PIPELINE_OK) |
1008 EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH)); | 1012 EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH)); |
1009 | 1013 |
(...skipping 120 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1130 INSTANTIATE_TEARDOWN_TEST(Error, InitDemuxer); | 1134 INSTANTIATE_TEARDOWN_TEST(Error, InitDemuxer); |
1131 INSTANTIATE_TEARDOWN_TEST(Error, InitAudioRenderer); | 1135 INSTANTIATE_TEARDOWN_TEST(Error, InitAudioRenderer); |
1132 INSTANTIATE_TEARDOWN_TEST(Error, InitVideoRenderer); | 1136 INSTANTIATE_TEARDOWN_TEST(Error, InitVideoRenderer); |
1133 INSTANTIATE_TEARDOWN_TEST(Error, Flushing); | 1137 INSTANTIATE_TEARDOWN_TEST(Error, Flushing); |
1134 INSTANTIATE_TEARDOWN_TEST(Error, Seeking); | 1138 INSTANTIATE_TEARDOWN_TEST(Error, Seeking); |
1135 INSTANTIATE_TEARDOWN_TEST(Error, Playing); | 1139 INSTANTIATE_TEARDOWN_TEST(Error, Playing); |
1136 | 1140 |
1137 INSTANTIATE_TEARDOWN_TEST(ErrorAndStop, Playing); | 1141 INSTANTIATE_TEARDOWN_TEST(ErrorAndStop, Playing); |
1138 | 1142 |
1139 } // namespace media | 1143 } // namespace media |
OLD | NEW |