Skip to content

GitLab

T
tangled
Commit c2fd0e4d authored by scherkus@chromium.org's avatar scherkus@chromium.org
Browse files
Options

Fold Pipeline initialization failure tests added in r150636 into PipelineTeardownTest. 

As a bonus we now get coverage on stopping-while-initializing!

Review URL: https://chromiumcodereview.appspot.com/10834266

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@151075 0039d316-1c4b-4281-b951-d872f2087c98
parent 4b0dcd8a
Hide whitespace changes
Inline Side-by-side
Showing with 198 additions and 121 deletions
media/base/pipeline_unittest.cc
View file @ c2fd0e4d
......@@ -878,114 +878,6 @@ TEST_F(PipelineTest, AudioTimeUpdateDuringSeek) {
EXPECT_EQ(pipeline_->GetMediaTime(), new_time);
}
TEST_F(PipelineTest, InitFailure_Demuxer) {
PipelineStatus expected_status = DEMUXER_ERROR_COULD_NOT_OPEN;
EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
.WillOnce(RunPipelineStatusCBWithStatus(expected_status));
EXPECT_CALL(*mocks_->demuxer(), Stop(_))
.WillOnce(RunClosure());
InitializePipeline(expected_status);
}
TEST_F(PipelineTest, InitFailure_AudioDecoder) {
CreateAudioStream();
MockDemuxerStreamVector streams;
streams.push_back(audio_stream());
InitializeDemuxer(&streams);
PipelineStatus expected_status = PIPELINE_ERROR_DECODE;
scoped_refptr<DemuxerStream> stream = streams[0];
EXPECT_CALL(*mocks_->audio_decoder(), Initialize(stream, _, _))
.WillOnce(RunPipelineStatusCBWithStatus(expected_status));
EXPECT_CALL(*mocks_->demuxer(), Stop(_))
.WillOnce(RunClosure());
InitializePipeline(expected_status);
EXPECT_FALSE(pipeline_->HasAudio());
}
TEST_F(PipelineTest, InitFailure_AudioRenderer) {
CreateAudioStream();
MockDemuxerStreamVector streams;
streams.push_back(audio_stream());
InitializeDemuxer(&streams);
InitializeAudioDecoder(audio_stream());
PipelineStatus expected_status = PIPELINE_ERROR_INITIALIZATION_FAILED;
EXPECT_CALL(*mocks_->audio_renderer(), Initialize(
scoped_refptr<AudioDecoder>(mocks_->audio_decoder()),
_, _, _, _, _, _))
.WillOnce(RunPipelineStatusCBWithStatus(expected_status));
EXPECT_CALL(*mocks_->demuxer(), Stop(_))
.WillOnce(RunClosure());
EXPECT_CALL(*mocks_->audio_renderer(), Stop(_))
.WillOnce(RunClosure());
InitializePipeline(expected_status);
EXPECT_TRUE(pipeline_->HasAudio());
}
TEST_F(PipelineTest, InitFailure_VideoDecoder) {
CreateAudioStream();
CreateVideoStream();
MockDemuxerStreamVector streams;
streams.push_back(audio_stream());
streams.push_back(video_stream());
InitializeDemuxer(&streams);
InitializeAudioDecoder(audio_stream());
InitializeAudioRenderer();
PipelineStatus expected_status = PIPELINE_ERROR_DECODE;
scoped_refptr<DemuxerStream> stream = streams[1];
EXPECT_CALL(*mocks_->video_decoder(),
Initialize(stream, _, _))
.WillOnce(RunPipelineStatusCBWithStatus(expected_status));
EXPECT_CALL(*mocks_->demuxer(), Stop(_))
.WillOnce(RunClosure());
EXPECT_CALL(*mocks_->audio_renderer(), Stop(_))
.WillOnce(RunClosure());
InitializePipeline(expected_status);
EXPECT_TRUE(pipeline_->HasAudio());
EXPECT_FALSE(pipeline_->HasVideo());
}
TEST_F(PipelineTest, InitFailure_VideoRenderer) {
CreateAudioStream();
CreateVideoStream();
MockDemuxerStreamVector streams;
streams.push_back(audio_stream());
streams.push_back(video_stream());
InitializeDemuxer(&streams);
InitializeAudioDecoder(audio_stream());
InitializeAudioRenderer();
InitializeVideoDecoder(video_stream());
PipelineStatus expected_status = PIPELINE_ERROR_INITIALIZATION_FAILED;
EXPECT_CALL(*mocks_->video_renderer(), Initialize(
scoped_refptr<VideoDecoder>(mocks_->video_decoder()),
_, _, _, _, _, _, _, _))
.WillOnce(RunPipelineStatusCBWithStatus(expected_status));
EXPECT_CALL(*mocks_->demuxer(), Stop(_))
.WillOnce(RunClosure());
EXPECT_CALL(*mocks_->audio_renderer(), Stop(_))
.WillOnce(RunClosure());
EXPECT_CALL(*mocks_->video_renderer(), Stop(_))
.WillOnce(RunClosure());
InitializePipeline(expected_status);
EXPECT_TRUE(pipeline_->HasAudio());
EXPECT_TRUE(pipeline_->HasVideo());
}
class FlexibleCallbackRunner : public base::DelegateSimpleThread::Delegate {
public:
FlexibleCallbackRunner(base::TimeDelta delay, PipelineStatus status,
......@@ -1042,6 +934,11 @@ TEST(PipelineStatusNotificationTest, DelayedCallback) {
class PipelineTeardownTest : public PipelineTest {
public:
enum TeardownState {
kInitDemuxer,
kInitAudioDecoder,
kInitAudioRenderer,
kInitVideoDecoder,
kInitVideoRenderer,
kPausing,
kFlushing,
kSeeking,
......@@ -1055,25 +952,27 @@ class PipelineTeardownTest : public PipelineTest {
kError,
};
PipelineTeardownTest() {
CreateAudioStream();
MockDemuxerStreamVector streams;
streams.push_back(audio_stream());
InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(3000));
InitializeAudioDecoder(audio_stream());
InitializeAudioRenderer();
InitializePipeline(PIPELINE_OK);
}
PipelineTeardownTest() {}
virtual ~PipelineTeardownTest() {}
void RunTest(TeardownState state, StopOrError stop_or_error) {
InSequence s;
switch (state) {
case kInitDemuxer:
case kInitAudioDecoder:
case kInitAudioRenderer:
case kInitVideoDecoder:
case kInitVideoRenderer:
DoInitialize(state, stop_or_error);
break;
case kPausing:
case kFlushing:
case kSeeking:
case kPrerolling:
case kStarting:
case kStarting: {
DoInitialize(state, stop_or_error);
InSequence s;
if (stop_or_error == kStop) {
ExpectSeekStop(state);
} else {
......@@ -1081,8 +980,12 @@ class PipelineTeardownTest : public PipelineTest {
}
DoSeek();
break;
}
case kPlaying: {
DoInitialize(state, stop_or_error);
case kPlaying:
InSequence s;
if (stop_or_error == kStop) {
ExpectStop();
DoStop();
......@@ -1091,6 +994,7 @@ class PipelineTeardownTest : public PipelineTest {
DoPlaybackError();
}
break;
}
}
}
......@@ -1098,6 +1002,146 @@ class PipelineTeardownTest : public PipelineTest {
// TODO(scherkus): We do radically different things whether teardown is
// invoked via stop vs error. The teardown path should be the same,
// see http://crbug.com/110228
void DoInitialize(TeardownState state, StopOrError stop_or_error) {
PipelineStatus expected_status =
SetInitializeExpectations(state, stop_or_error);
EXPECT_CALL(callbacks_, OnStart(expected_status));
pipeline_->Start(
mocks_->Create().Pass(),
base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)));
message_loop_.RunAllPending();
}
PipelineStatus SetInitializeExpectations(TeardownState state,
StopOrError stop_or_error) {
PipelineStatus status = PIPELINE_OK;
base::Closure stop_cb = base::Bind(
&CallbackHelper::OnStop, base::Unretained(&callbacks_));
if (state == kInitDemuxer) {
if (stop_or_error == kStop) {
EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
.WillOnce(DoAll(Stop(pipeline_, stop_cb), RunPipelineStatusCB()));
EXPECT_CALL(callbacks_, OnStop());
} else {
status = DEMUXER_ERROR_COULD_NOT_OPEN;
EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
.WillOnce(RunPipelineStatusCBWithStatus(status));
}
EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
return status;
}
CreateAudioStream();
CreateVideoStream();
MockDemuxerStreamVector streams;
streams.push_back(audio_stream());
streams.push_back(video_stream());
InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(3000));
if (state == kInitAudioDecoder) {
if (stop_or_error == kStop) {
EXPECT_CALL(*mocks_->audio_decoder(), Initialize(_, _, _))
.WillOnce(DoAll(Stop(pipeline_, stop_cb), RunPipelineStatusCB()));
EXPECT_CALL(callbacks_, OnStop());
} else {
status = PIPELINE_ERROR_DECODE;
EXPECT_CALL(*mocks_->audio_decoder(), Initialize(_, _, _))
.WillOnce(RunPipelineStatusCBWithStatus(status));
}
EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
return status;
}
EXPECT_CALL(*mocks_->audio_decoder(), Initialize(_, _, _))
.WillOnce(RunPipelineStatusCB());
if (state == kInitAudioRenderer) {
if (stop_or_error == kStop) {
EXPECT_CALL(*mocks_->audio_renderer(), Initialize(_, _, _, _, _, _, _))
.WillOnce(DoAll(Stop(pipeline_, stop_cb), RunPipelineStatusCB()));
EXPECT_CALL(callbacks_, OnStop());
} else {
status = PIPELINE_ERROR_INITIALIZATION_FAILED;
EXPECT_CALL(*mocks_->audio_renderer(), Initialize(_, _, _, _, _, _, _))
.WillOnce(RunPipelineStatusCBWithStatus(status));
}
EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
return status;
}
EXPECT_CALL(*mocks_->audio_renderer(), Initialize(_, _, _, _, _, _, _))
.WillOnce(RunPipelineStatusCB());
if (state == kInitVideoDecoder) {
if (stop_or_error == kStop) {
EXPECT_CALL(*mocks_->video_decoder(), Initialize(_, _, _))
.WillOnce(DoAll(Stop(pipeline_, stop_cb), RunPipelineStatusCB()));
EXPECT_CALL(callbacks_, OnStop());
} else {
status = PIPELINE_ERROR_DECODE;
EXPECT_CALL(*mocks_->video_decoder(), Initialize(_, _, _))
.WillOnce(RunPipelineStatusCBWithStatus(status));
}
EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
return status;
}
EXPECT_CALL(*mocks_->video_decoder(), Initialize(_, _, _))
.WillOnce(RunPipelineStatusCB());
if (state == kInitVideoRenderer) {
if (stop_or_error == kStop) {
EXPECT_CALL(*mocks_->video_renderer(),
Initialize(_, _, _, _, _, _, _, _, _))
.WillOnce(DoAll(Stop(pipeline_, stop_cb), RunPipelineStatusCB()));
EXPECT_CALL(callbacks_, OnStop());
} else {
status = PIPELINE_ERROR_INITIALIZATION_FAILED;
EXPECT_CALL(*mocks_->video_renderer(),
Initialize(_, _, _, _, _, _, _, _, _))
.WillOnce(RunPipelineStatusCBWithStatus(status));
}
EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
EXPECT_CALL(*mocks_->video_renderer(), Stop(_)).WillOnce(RunClosure());
return status;
}
EXPECT_CALL(*mocks_->video_renderer(),
Initialize(_, _, _, _, _, _, _, _, _))
.WillOnce(RunPipelineStatusCB());
// If we get here it's a successful initialization.
EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(0.0f));
EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(0.0f));
EXPECT_CALL(*mocks_->video_renderer(), SetPlaybackRate(0.0f));
EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(1.0f));
EXPECT_CALL(*mocks_->audio_renderer(), Preroll(base::TimeDelta(), _))
.WillOnce(RunPipelineStatusCB());
EXPECT_CALL(*mocks_->video_renderer(), Preroll(base::TimeDelta(), _))
.WillOnce(RunPipelineStatusCB());
EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
.WillOnce(RunClosure());
EXPECT_CALL(*mocks_->video_renderer(), Play(_))
.WillOnce(RunClosure());
return status;
}
void ExpectSeekStop(TeardownState state) {
base::Closure stop_cb = base::Bind(
&CallbackHelper::OnStop, base::Unretained(&callbacks_));
......@@ -1109,6 +1153,8 @@ class PipelineTeardownTest : public PipelineTest {
EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
}
EXPECT_CALL(*mocks_->video_renderer(), Pause(_)).WillOnce(RunClosure());
if (state == kFlushing) {
EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
.WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure()));
......@@ -1116,6 +1162,8 @@ class PipelineTeardownTest : public PipelineTest {
EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure());
}
EXPECT_CALL(*mocks_->video_renderer(), Flush(_)).WillOnce(RunClosure());
if (state == kSeeking) {
EXPECT_CALL(*mocks_->demuxer(), Seek(_, _))
.WillOnce(DoAll(Stop(pipeline_, stop_cb), RunPipelineStatusCB()));
......@@ -1132,6 +1180,9 @@ class PipelineTeardownTest : public PipelineTest {
.WillOnce(RunPipelineStatusCB());
}
EXPECT_CALL(*mocks_->video_renderer(), Preroll(_, _))
.WillOnce(RunPipelineStatusCB());
if (state == kStarting) {
EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
.WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure()));
......@@ -1139,6 +1190,8 @@ class PipelineTeardownTest : public PipelineTest {
EXPECT_CALL(*mocks_->audio_renderer(), Play(_)).WillOnce(RunClosure());
}
EXPECT_CALL(*mocks_->video_renderer(), Play(_)).WillOnce(RunClosure());
EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
ExpectStop();
}
......@@ -1150,6 +1203,7 @@ class PipelineTeardownTest : public PipelineTest {
EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
EXPECT_CALL(*mocks_->video_renderer(), Stop(_)).WillOnce(RunClosure());
}
void SetSeekErrorExpectations(TeardownState state) {
......@@ -1157,19 +1211,23 @@ class PipelineTeardownTest : public PipelineTest {
EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
.WillOnce(DoAll(SetError(pipeline_, PIPELINE_ERROR_READ),
RunClosure()));
EXPECT_CALL(*mocks_->video_renderer(), Pause(_)).WillOnce(RunClosure());
return;
}
EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
EXPECT_CALL(*mocks_->video_renderer(), Pause(_)).WillOnce(RunClosure());
if (state == kFlushing) {
EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
.WillOnce(DoAll(SetError(pipeline_, PIPELINE_ERROR_READ),
RunClosure()));
EXPECT_CALL(*mocks_->video_renderer(), Flush(_)).WillOnce(RunClosure());
return;
}
EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure());
EXPECT_CALL(*mocks_->video_renderer(), Flush(_)).WillOnce(RunClosure());
if (state == kSeeking) {
EXPECT_CALL(*mocks_->demuxer(), Seek(_, _))
......@@ -1188,11 +1246,14 @@ class PipelineTeardownTest : public PipelineTest {
EXPECT_CALL(*mocks_->audio_renderer(), Preroll(_, _))
.WillOnce(RunPipelineStatusCB());
EXPECT_CALL(*mocks_->video_renderer(), Preroll(_, _))
.WillOnce(RunPipelineStatusCB());
if (state == kStarting) {
EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
.WillOnce(DoAll(SetError(pipeline_, PIPELINE_ERROR_READ),
RunClosure()));
EXPECT_CALL(*mocks_->video_renderer(), Play(_)).WillOnce(RunClosure());
return;
}
......@@ -1202,9 +1263,12 @@ class PipelineTeardownTest : public PipelineTest {
void ExpectStop() {
// TODO(scherkus): Don't pause+flush, see http://crbug.com/110228
EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
EXPECT_CALL(*mocks_->video_renderer(), Pause(_)).WillOnce(RunClosure());
EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure());
EXPECT_CALL(*mocks_->video_renderer(), Flush(_)).WillOnce(RunClosure());
EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
EXPECT_CALL(*mocks_->video_renderer(), Stop(_)).WillOnce(RunClosure());
EXPECT_CALL(callbacks_, OnStop());
}
......@@ -1212,9 +1276,12 @@ class PipelineTeardownTest : public PipelineTest {
void ExpectPlaybackError() {
// TODO(scherkus): Don't pause+flush, see http://crbug.com/110228
EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
EXPECT_CALL(*mocks_->video_renderer(), Pause(_)).WillOnce(RunClosure());
EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure());
EXPECT_CALL(*mocks_->video_renderer(), Flush(_)).WillOnce(RunClosure());
EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
EXPECT_CALL(*mocks_->video_renderer(), Stop(_)).WillOnce(RunClosure());
EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_READ));
}
......@@ -1244,6 +1311,11 @@ class PipelineTeardownTest : public PipelineTest {
RunTest(k##state, k##stop_or_error); \
}
INSTANTIATE_TEARDOWN_TEST(Stop, InitDemuxer);
INSTANTIATE_TEARDOWN_TEST(Stop, InitAudioDecoder);
INSTANTIATE_TEARDOWN_TEST(Stop, InitAudioRenderer);
INSTANTIATE_TEARDOWN_TEST(Stop, InitVideoDecoder);
INSTANTIATE_TEARDOWN_TEST(Stop, InitVideoRenderer);
INSTANTIATE_TEARDOWN_TEST(Stop, Pausing);
INSTANTIATE_TEARDOWN_TEST(Stop, Flushing);
INSTANTIATE_TEARDOWN_TEST(Stop, Seeking);
......@@ -1251,6 +1323,11 @@ INSTANTIATE_TEARDOWN_TEST(Stop, Prerolling);
INSTANTIATE_TEARDOWN_TEST(Stop, Starting);
INSTANTIATE_TEARDOWN_TEST(Stop, Playing);
INSTANTIATE_TEARDOWN_TEST(Error, InitDemuxer);
INSTANTIATE_TEARDOWN_TEST(Error, InitAudioDecoder);
INSTANTIATE_TEARDOWN_TEST(Error, InitAudioRenderer);
INSTANTIATE_TEARDOWN_TEST(Error, InitVideoDecoder);
INSTANTIATE_TEARDOWN_TEST(Error, InitVideoRenderer);
INSTANTIATE_TEARDOWN_TEST(Error, Pausing);
INSTANTIATE_TEARDOWN_TEST(Error, Flushing);
INSTANTIATE_TEARDOWN_TEST(Error, Seeking);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment