Some cleanup in PipelineTest.

media/base/pipeline_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/test/simple_test_tick_clock.h"
@@ skipping 87 matching lines @@
     scoped_ptr<AudioRenderer> audio_renderer(audio_renderer_);
     filter_collection_->SetAudioRenderer(audio_renderer.Pass());
 
     text_renderer_ = new TextRenderer(
                          message_loop_.message_loop_proxy(),
                          base::Bind(&PipelineTest::OnAddTextTrack,
                                     base::Unretained(this)));
     scoped_ptr<TextRenderer> text_renderer(text_renderer_);
     filter_collection_->SetTextRenderer(text_renderer.Pass());
 
-    // InitializeDemuxer() adds overriding expectations for expected non-NULL
-    // streams.
+    // ExpectToInitializeDemuxer() adds overriding expectations for expected
+    // non-NULL streams.
     DemuxerStream* null_pointer = NULL;
     EXPECT_CALL(*demuxer_, GetStream(_))
         .WillRepeatedly(Return(null_pointer));
 
     EXPECT_CALL(*demuxer_, GetTimelineOffset())
         .WillRepeatedly(Return(base::Time()));
 
     EXPECT_CALL(*demuxer_, GetLiveness())
         .WillRepeatedly(Return(Demuxer::LIVENESS_UNKNOWN));
   }
@@ skipping 14 matching lines @@
     // Expect a stop callback if we were started.
     EXPECT_CALL(callbacks_, OnStop());
     pipeline_->Stop(base::Bind(&CallbackHelper::OnStop,
                                base::Unretained(&callbacks_)));
     message_loop_.RunUntilIdle();
   }
 
  protected:
   // Sets up expectations to allow the demuxer to initialize.
   typedef std::vector<MockDemuxerStream*> MockDemuxerStreamVector;
-  void InitializeDemuxer(MockDemuxerStreamVector* streams,
+  void ExpectToInitializeDemuxer(MockDemuxerStreamVector* streams,

[scherkus (not reviewing), 2014/07/11 19:22:52]

suggestion: in the PipelineTeardownTests I used "SetXXXExpectations()"

I don't mind but picking one would be good

[xhwang, 2014/07/11 20:36:04]

Done.

                          const base::TimeDelta& duration) {
     EXPECT_CALL(callbacks_, OnDurationChange());
     EXPECT_CALL(*demuxer_, Initialize(_, _, _))
         .WillOnce(DoAll(SetDemuxerProperties(duration),
                         RunCallback<1>(PIPELINE_OK)));
 
     // Configure the demuxer to return the streams.
     for (size_t i = 0; i < streams->size(); ++i) {
       DemuxerStream* stream = (*streams)[i];
       EXPECT_CALL(*demuxer_, GetStream(stream->type()))
           .WillRepeatedly(Return(stream));
     }
   }
 
-  void InitializeDemuxer(MockDemuxerStreamVector* streams) {
+  void ExpectToInitializeDemuxer(MockDemuxerStreamVector* streams) {
     // Initialize with a default non-zero duration.
-    InitializeDemuxer(streams, base::TimeDelta::FromSeconds(10));
+    ExpectToInitializeDemuxer(streams, base::TimeDelta::FromSeconds(10));
   }
 
   scoped_ptr<StrictMock<MockDemuxerStream> > CreateStream(
       DemuxerStream::Type type) {
     scoped_ptr<StrictMock<MockDemuxerStream> > stream(
         new StrictMock<MockDemuxerStream>(type));
     return stream.Pass();
   }
 
   // Sets up expectations to allow the video renderer to initialize.
-  void InitializeVideoRenderer(DemuxerStream* stream) {
+  void ExpectToInitializeVideoRenderer(DemuxerStream* stream) {
     EXPECT_CALL(*video_renderer_, Initialize(stream, _, _, _, _, _, _, _, _, _))
         .WillOnce(DoAll(SaveArg<5>(&video_buffering_state_cb_),
+                        SaveArg<6>(&video_ended_cb_),
                         RunCallback<2>(PIPELINE_OK)));
   }
 
   // Sets up expectations to allow the audio renderer to initialize.
-  void InitializeAudioRenderer(DemuxerStream* stream) {
+  void ExpectToInitializeAudioRenderer(DemuxerStream* stream) {
     EXPECT_CALL(*audio_renderer_, Initialize(stream, _, _, _, _, _, _))
         .WillOnce(DoAll(SaveArg<3>(&audio_time_cb_),
                         SaveArg<4>(&audio_buffering_state_cb_),
+                        SaveArg<5>(&audio_ended_cb_),
                         RunCallback<1>(PIPELINE_OK)));
   }
 
   void AddTextStream() {
     EXPECT_CALL(*this, OnAddTextTrack(_,_))
         .WillOnce(Invoke(this, &PipelineTest::DoOnAddTextTrack));
     static_cast<DemuxerHost*>(pipeline_.get())->AddTextStream(text_stream(),
                               TextTrackConfig(kTextSubtitles, "", "", ""));
   }
 
   // Sets up expectations on the callback and initializes the pipeline.  Called
   // after tests have set expectations any filters they wish to use.
-  void InitializePipeline(PipelineStatus start_status) {
+  void StartPipeline(PipelineStatus start_status) {
     EXPECT_CALL(callbacks_, OnStart(start_status));
 
     if (start_status == PIPELINE_OK) {
       EXPECT_CALL(callbacks_, OnMetadata(_)).WillOnce(SaveArg<0>(&metadata_));
 
       if (audio_stream_) {
         EXPECT_CALL(*audio_renderer_, SetPlaybackRate(0.0f));
         EXPECT_CALL(*audio_renderer_, SetVolume(1.0f));
         EXPECT_CALL(*audio_renderer_, StartPlayingFrom(base::TimeDelta()))
             .WillOnce(SetBufferingState(&audio_buffering_state_cb_,
@@ skipping 129 matching lines @@
   MockVideoRenderer* video_renderer_;
   MockAudioRenderer* audio_renderer_;
   StrictMock<CallbackHelper> text_renderer_callbacks_;
   TextRenderer* text_renderer_;
   scoped_ptr<StrictMock<MockDemuxerStream> > audio_stream_;
   scoped_ptr<StrictMock<MockDemuxerStream> > video_stream_;
   scoped_ptr<FakeTextTrackStream> text_stream_;
   AudioRenderer::TimeCB audio_time_cb_;
   BufferingStateCB audio_buffering_state_cb_;
   BufferingStateCB video_buffering_state_cb_;
+  base::Closure audio_ended_cb_;
+  base::Closure video_ended_cb_;
   VideoDecoderConfig video_decoder_config_;
   PipelineMetadata metadata_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PipelineTest);
 };
 
 // Test that playback controls methods no-op when the pipeline hasn't been
 // started.
 TEST_F(PipelineTest, NotStarted) {
@@ skipping 46 matching lines @@
   Mock::VerifyAndClear(&callbacks_);
   EXPECT_CALL(callbacks_, OnStart(PIPELINE_OK));
 }
 
 TEST_F(PipelineTest, URLNotFound) {
   EXPECT_CALL(*demuxer_, Initialize(_, _, _))
       .WillOnce(RunCallback<1>(PIPELINE_ERROR_URL_NOT_FOUND));
   EXPECT_CALL(*demuxer_, Stop(_))
       .WillOnce(RunClosure<0>());
 
-  InitializePipeline(PIPELINE_ERROR_URL_NOT_FOUND);
+  StartPipeline(PIPELINE_ERROR_URL_NOT_FOUND);
 }
 
 TEST_F(PipelineTest, NoStreams) {
   EXPECT_CALL(*demuxer_, Initialize(_, _, _))
       .WillOnce(RunCallback<1>(PIPELINE_OK));
   EXPECT_CALL(*demuxer_, Stop(_))
       .WillOnce(RunClosure<0>());
 
-  InitializePipeline(PIPELINE_ERROR_COULD_NOT_RENDER);
+  StartPipeline(PIPELINE_ERROR_COULD_NOT_RENDER);
 }
 
 TEST_F(PipelineTest, AudioStream) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
-  InitializeDemuxer(&streams);
-  InitializeAudioRenderer(audio_stream());
+  ExpectToInitializeDemuxer(&streams);
+  ExpectToInitializeAudioRenderer(audio_stream());
 
-  InitializePipeline(PIPELINE_OK);
+  StartPipeline(PIPELINE_OK);
   EXPECT_TRUE(metadata_.has_audio);
   EXPECT_FALSE(metadata_.has_video);
 }
 
 TEST_F(PipelineTest, VideoStream) {
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
-  InitializeDemuxer(&streams);
-  InitializeVideoRenderer(video_stream());
+  ExpectToInitializeDemuxer(&streams);
+  ExpectToInitializeVideoRenderer(video_stream());
 
-  InitializePipeline(PIPELINE_OK);
+  StartPipeline(PIPELINE_OK);
   EXPECT_FALSE(metadata_.has_audio);
   EXPECT_TRUE(metadata_.has_video);
 }
 
 TEST_F(PipelineTest, AudioVideoStream) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
-  InitializeDemuxer(&streams);
-  InitializeAudioRenderer(audio_stream());
-  InitializeVideoRenderer(video_stream());
+  ExpectToInitializeDemuxer(&streams);
+  ExpectToInitializeAudioRenderer(audio_stream());
+  ExpectToInitializeVideoRenderer(video_stream());
 
-  InitializePipeline(PIPELINE_OK);
+  StartPipeline(PIPELINE_OK);
   EXPECT_TRUE(metadata_.has_audio);
   EXPECT_TRUE(metadata_.has_video);
 }
 
 TEST_F(PipelineTest, VideoTextStream) {
   CreateVideoStream();
   CreateTextStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
-  InitializeDemuxer(&streams);
-  InitializeVideoRenderer(video_stream());
+  ExpectToInitializeDemuxer(&streams);
+  ExpectToInitializeVideoRenderer(video_stream());
 
-  InitializePipeline(PIPELINE_OK);
+  StartPipeline(PIPELINE_OK);
   EXPECT_FALSE(metadata_.has_audio);
   EXPECT_TRUE(metadata_.has_video);
 
   AddTextStream();
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(PipelineTest, VideoAudioTextStream) {
   CreateVideoStream();
   CreateAudioStream();
   CreateTextStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
   streams.push_back(audio_stream());
 
-  InitializeDemuxer(&streams);
-  InitializeVideoRenderer(video_stream());
-  InitializeAudioRenderer(audio_stream());
+  ExpectToInitializeDemuxer(&streams);
+  ExpectToInitializeVideoRenderer(video_stream());
+  ExpectToInitializeAudioRenderer(audio_stream());
 
-  InitializePipeline(PIPELINE_OK);
+  StartPipeline(PIPELINE_OK);
   EXPECT_TRUE(metadata_.has_audio);
   EXPECT_TRUE(metadata_.has_video);
 
   AddTextStream();
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(PipelineTest, Seek) {
   CreateAudioStream();
   CreateVideoStream();
   CreateTextStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
-  InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(3000));
-  InitializeAudioRenderer(audio_stream());
-  InitializeVideoRenderer(video_stream());
+  ExpectToInitializeDemuxer(&streams, base::TimeDelta::FromSeconds(3000));
+  ExpectToInitializeAudioRenderer(audio_stream());
+  ExpectToInitializeVideoRenderer(video_stream());
 
   // Initialize then seek!
-  InitializePipeline(PIPELINE_OK);
+  StartPipeline(PIPELINE_OK);
 
   message_loop_.RunUntilIdle();
 
   // Every filter should receive a call to Seek().
   base::TimeDelta expected = base::TimeDelta::FromSeconds(2000);
   ExpectSeek(expected, false);
   DoSeek(expected);
 }
 
 TEST_F(PipelineTest, SetVolume) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
-  InitializeDemuxer(&streams);
-  InitializeAudioRenderer(audio_stream());
+  ExpectToInitializeDemuxer(&streams);
+  ExpectToInitializeAudioRenderer(audio_stream());
 
   // The audio renderer should receive a call to SetVolume().
   float expected = 0.5f;
   EXPECT_CALL(*audio_renderer_, SetVolume(expected));
 
   // Initialize then set volume!
-  InitializePipeline(PIPELINE_OK);
+  StartPipeline(PIPELINE_OK);
   pipeline_->SetVolume(expected);
 }
 
 TEST_F(PipelineTest, Properties) {
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
-  InitializeDemuxer(&streams, kDuration);
-  InitializeVideoRenderer(video_stream());
+  ExpectToInitializeDemuxer(&streams, kDuration);
+  ExpectToInitializeVideoRenderer(video_stream());
 
-  InitializePipeline(PIPELINE_OK);
+  StartPipeline(PIPELINE_OK);
   EXPECT_EQ(kDuration.ToInternalValue(),
             pipeline_->GetMediaDuration().ToInternalValue());
   EXPECT_FALSE(pipeline_->DidLoadingProgress());
 }
 
 TEST_F(PipelineTest, GetBufferedTimeRanges) {
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
-  InitializeDemuxer(&streams, kDuration);
-  InitializeVideoRenderer(video_stream());
+  ExpectToInitializeDemuxer(&streams, kDuration);
+  ExpectToInitializeVideoRenderer(video_stream());
 
-  InitializePipeline(PIPELINE_OK);
+  StartPipeline(PIPELINE_OK);
 
   EXPECT_EQ(0u, pipeline_->GetBufferedTimeRanges().size());
 
   EXPECT_FALSE(pipeline_->DidLoadingProgress());
   pipeline_->AddBufferedTimeRange(base::TimeDelta(), kDuration / 8);
   EXPECT_TRUE(pipeline_->DidLoadingProgress());
   EXPECT_FALSE(pipeline_->DidLoadingProgress());
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(base::TimeDelta(), pipeline_->GetBufferedTimeRanges().start(0));
   EXPECT_EQ(kDuration / 8, pipeline_->GetBufferedTimeRanges().end(0));
 
   base::TimeDelta kSeekTime = kDuration / 2;
   ExpectSeek(kSeekTime, false);
   DoSeek(kSeekTime);
 
   EXPECT_FALSE(pipeline_->DidLoadingProgress());
 }
 
 TEST_F(PipelineTest, EndedCallback) {
   CreateAudioStream();
   CreateVideoStream();
   CreateTextStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
-  InitializeDemuxer(&streams);
-  InitializeAudioRenderer(audio_stream());
-  InitializeVideoRenderer(video_stream());
-  InitializePipeline(PIPELINE_OK);
+  ExpectToInitializeDemuxer(&streams);
+  ExpectToInitializeAudioRenderer(audio_stream());
+  ExpectToInitializeVideoRenderer(video_stream());
+  StartPipeline(PIPELINE_OK);
 
   AddTextStream();
 
   // The ended callback shouldn't run until all renderers have ended.
-  pipeline_->OnAudioRendererEnded();
+  audio_ended_cb_.Run();
   message_loop_.RunUntilIdle();
 
-  pipeline_->OnVideoRendererEnded();
+  video_ended_cb_.Run();
   message_loop_.RunUntilIdle();
 
   EXPECT_CALL(*audio_renderer_, StopRendering());
   EXPECT_CALL(callbacks_, OnEnded());
   text_stream()->SendEosNotification();
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(PipelineTest, AudioStreamShorterThanVideo) {
   base::TimeDelta duration = base::TimeDelta::FromSeconds(10);
 
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   // Replace what's used for interpolating to simulate wall clock time.
   pipeline_->SetTimeDeltaInterpolatorForTesting(
       new TimeDeltaInterpolator(&test_tick_clock_));
 
-  InitializeDemuxer(&streams, duration);
-  InitializeAudioRenderer(audio_stream());
-  InitializeVideoRenderer(video_stream());
-  InitializePipeline(PIPELINE_OK);
+  ExpectToInitializeDemuxer(&streams, duration);
+  ExpectToInitializeAudioRenderer(audio_stream());
+  ExpectToInitializeVideoRenderer(video_stream());
+  StartPipeline(PIPELINE_OK);
 
   EXPECT_EQ(0, pipeline_->GetMediaTime().ToInternalValue());
 
   float playback_rate = 1.0f;
   EXPECT_CALL(*video_renderer_, SetPlaybackRate(playback_rate));
   EXPECT_CALL(*audio_renderer_, SetPlaybackRate(playback_rate));
   pipeline_->SetPlaybackRate(playback_rate);
   message_loop_.RunUntilIdle();
 
   InSequence s;
 
   // Verify that the clock doesn't advance since it hasn't been started by
   // a time update from the audio stream.
   int64 start_time = pipeline_->GetMediaTime().ToInternalValue();
   test_tick_clock_.Advance(base::TimeDelta::FromMilliseconds(100));
   EXPECT_EQ(pipeline_->GetMediaTime().ToInternalValue(), start_time);
 
   // Signal end of audio stream.
-  pipeline_->OnAudioRendererEnded();
+  audio_ended_cb_.Run();
   message_loop_.RunUntilIdle();
 
   // Verify that the clock advances.
   start_time = pipeline_->GetMediaTime().ToInternalValue();
   test_tick_clock_.Advance(base::TimeDelta::FromMilliseconds(100));
   EXPECT_GT(pipeline_->GetMediaTime().ToInternalValue(), start_time);
 
   // Signal end of video stream and make sure OnEnded() callback occurs.
   EXPECT_CALL(*audio_renderer_, StopRendering());
   EXPECT_CALL(callbacks_, OnEnded());
-  pipeline_->OnVideoRendererEnded();
+  video_ended_cb_.Run();
 }
 
 TEST_F(PipelineTest, ErrorDuringSeek) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
-  InitializeDemuxer(&streams);
-  InitializeAudioRenderer(audio_stream());
-  InitializePipeline(PIPELINE_OK);
+  ExpectToInitializeDemuxer(&streams);
+  ExpectToInitializeAudioRenderer(audio_stream());
+  StartPipeline(PIPELINE_OK);
 
   float playback_rate = 1.0f;
   EXPECT_CALL(*audio_renderer_, SetPlaybackRate(playback_rate));
   pipeline_->SetPlaybackRate(playback_rate);
   message_loop_.RunUntilIdle();
 
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(5);
 
   // Preroll() isn't called as the demuxer errors out first.
   EXPECT_CALL(*audio_renderer_, StopRendering());
@@ skipping 32 matching lines @@
 
   // No additional tasks should be queued as a result of these calls.
   EXPECT_TRUE(message_loop->IsIdleForTesting());
 }
 
 TEST_F(PipelineTest, NoMessageDuringTearDownFromError) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
-  InitializeDemuxer(&streams);
-  InitializeAudioRenderer(audio_stream());
-  InitializePipeline(PIPELINE_OK);
+  ExpectToInitializeDemuxer(&streams);
+  ExpectToInitializeAudioRenderer(audio_stream());
+  StartPipeline(PIPELINE_OK);
 
   // Trigger additional requests on the pipeline during tear down from error.
   base::Callback<void(PipelineStatus)> cb = base::Bind(
       &TestNoCallsAfterError, pipeline_.get(), &message_loop_);
   ON_CALL(callbacks_, OnError(_))
       .WillByDefault(Invoke(&cb, &base::Callback<void(PipelineStatus)>::Run));
 
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(5);
 
   // Seek() isn't called as the demuxer errors out first.
@@ skipping 21 matching lines @@
                        int max_time_in_ms) {
   time_cb.Run(base::TimeDelta::FromMilliseconds(time_in_ms),
               base::TimeDelta::FromMilliseconds(max_time_in_ms));
 }
 
 TEST_F(PipelineTest, AudioTimeUpdateDuringSeek) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
-  InitializeDemuxer(&streams);
-  InitializeAudioRenderer(audio_stream());
-  InitializePipeline(PIPELINE_OK);
+  ExpectToInitializeDemuxer(&streams);
+  ExpectToInitializeAudioRenderer(audio_stream());
+  StartPipeline(PIPELINE_OK);
 
   float playback_rate = 1.0f;
   EXPECT_CALL(*audio_renderer_, SetPlaybackRate(playback_rate));
   pipeline_->SetPlaybackRate(playback_rate);
   message_loop_.RunUntilIdle();
 
   // Provide an initial time update so that the pipeline transitions out of the
   // "waiting for time update" state.
   audio_time_cb_.Run(base::TimeDelta::FromMilliseconds(100),
                      base::TimeDelta::FromMilliseconds(500));
@@ skipping 35 matching lines @@
 }
 
 static void DeletePipeline(scoped_ptr<Pipeline> pipeline) {
   // |pipeline| will go out of scope.
 }
 
 TEST_F(PipelineTest, DeleteAfterStop) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
-  InitializeDemuxer(&streams);
-  InitializeAudioRenderer(audio_stream());
-  InitializePipeline(PIPELINE_OK);
+  ExpectToInitializeDemuxer(&streams);
+  ExpectToInitializeAudioRenderer(audio_stream());
+  StartPipeline(PIPELINE_OK);
 
   ExpectStop();
 
   Pipeline* pipeline = pipeline_.get();
   pipeline->Stop(base::Bind(&DeletePipeline, base::Passed(&pipeline_)));
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(PipelineTest, Underflow) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
-  InitializeDemuxer(&streams);
-  InitializeAudioRenderer(audio_stream());
-  InitializeVideoRenderer(video_stream());
-  InitializePipeline(PIPELINE_OK);
+  ExpectToInitializeDemuxer(&streams);
+  ExpectToInitializeAudioRenderer(audio_stream());
+  ExpectToInitializeVideoRenderer(video_stream());
+  StartPipeline(PIPELINE_OK);
 
   // Simulate underflow.
   EXPECT_CALL(*audio_renderer_, StopRendering());
   audio_buffering_state_cb_.Run(BUFFERING_HAVE_NOTHING);
 
   // Seek while underflowed. We shouldn't call StopRendering() again.
   base::TimeDelta expected = base::TimeDelta::FromSeconds(5);
   ExpectSeek(expected, true);
   DoSeek(expected);
 }
@@ skipping 81 matching lines @@
 
       EXPECT_CALL(*demuxer_, Stop(_)).WillOnce(RunClosure<0>());
       return status;
     }
 
     CreateAudioStream();
     CreateVideoStream();
     MockDemuxerStreamVector streams;
     streams.push_back(audio_stream());
     streams.push_back(video_stream());
-    InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(3000));
+    ExpectToInitializeDemuxer(&streams, base::TimeDelta::FromSeconds(3000));
 
     if (state == kInitAudioRenderer) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*audio_renderer_, Initialize(_, _, _, _, _, _, _))
             .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
                             RunCallback<1>(PIPELINE_OK)));
         EXPECT_CALL(callbacks_, OnStop());
       } else {
         status = PIPELINE_ERROR_INITIALIZATION_FAILED;
         EXPECT_CALL(*audio_renderer_, Initialize(_, _, _, _, _, _, _))
@@ skipping 172 matching lines @@
 INSTANTIATE_TEARDOWN_TEST(Error, InitDemuxer);
 INSTANTIATE_TEARDOWN_TEST(Error, InitAudioRenderer);
 INSTANTIATE_TEARDOWN_TEST(Error, InitVideoRenderer);
 INSTANTIATE_TEARDOWN_TEST(Error, Flushing);
 INSTANTIATE_TEARDOWN_TEST(Error, Seeking);
 INSTANTIATE_TEARDOWN_TEST(Error, Playing);
 
 INSTANTIATE_TEARDOWN_TEST(ErrorAndStop, Playing);
 
 }  // namespace media