Remove Pipeline::IsInitialized() and replace stop_pending_ with checks for stop_cb_.

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.h"
 #include "base/stl_util.h"
 #include "base/threading/simple_thread.h"
@@ skipping 85 matching lines @@
     EXPECT_CALL(*mocks_->demuxer(), GetStartTime())
         .WillRepeatedly(Return(base::TimeDelta()));
   }
 
   virtual ~PipelineTest() {
     if (!pipeline_->IsRunning()) {
       return;
     }
 
     // Shutdown sequence.
-    if (pipeline_->IsInitialized()) {
+    //
+    // TODO(scherkus): This check is required because in certain teardown
+    // cases the pipeline is still "running" but has already stopped due to
+    // errors. In an ideal world we stop running when we teardown, but that
+    // requires cleaning up shutdown path, see http://crbug.com/110228
+    if (pipeline_->IsInitializedForTesting()) {
       EXPECT_CALL(*mocks_->demuxer(), Stop(_))
           .WillOnce(RunClosure());
 
       // TODO(scherkus): Don't pause+flush on shutdown,
       // see http://crbug.com/110228
       if (audio_stream_) {
         EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
             .WillOnce(RunClosure());
         EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
             .WillOnce(RunClosure());
@@ skipping 195 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(PipelineTest);
 };
 
 // Test that playback controls methods no-op when the pipeline hasn't been
 // started.
 TEST_F(PipelineTest, NotStarted) {
   const base::TimeDelta kZero;
 
   EXPECT_FALSE(pipeline_->IsRunning());
-  EXPECT_FALSE(pipeline_->IsInitialized());
   EXPECT_FALSE(pipeline_->HasAudio());
   EXPECT_FALSE(pipeline_->HasVideo());
 
   // Setting should still work.
   EXPECT_EQ(0.0f, pipeline_->GetPlaybackRate());
   pipeline_->SetPlaybackRate(-1.0f);
   EXPECT_EQ(0.0f, pipeline_->GetPlaybackRate());
   pipeline_->SetPlaybackRate(1.0f);
   EXPECT_EQ(1.0f, pipeline_->GetPlaybackRate());
 
@@ skipping 26 matching lines @@
   // This test hangs during initialization by never calling
   // InitializationComplete().  StrictMock<> will ensure that the callback is
   // never executed.
   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();
 
-  EXPECT_FALSE(pipeline_->IsInitialized());
 
   // Because our callback will get executed when the test tears down, we'll
   // verify that nothing has been called, then set our expectation for the call
   // made during tear down.
   Mock::VerifyAndClear(&callbacks_);
   EXPECT_CALL(callbacks_, OnStart(PIPELINE_OK));
 }
 
 TEST_F(PipelineTest, RequiredFilterMissing) {
   // Create a filter collection with missing filter.
   scoped_ptr<FilterCollection> collection(mocks_->Create());
   collection->SetDemuxer(NULL);
 
   EXPECT_CALL(callbacks_, OnStart(PIPELINE_ERROR_REQUIRED_FILTER_MISSING));
   pipeline_->Start(
       collection.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();
-  EXPECT_FALSE(pipeline_->IsInitialized());
 }
 
 TEST_F(PipelineTest, URLNotFound) {
   EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
       .WillOnce(RunPipelineStatusCBWithStatus(PIPELINE_ERROR_URL_NOT_FOUND));
   EXPECT_CALL(*mocks_->demuxer(), Stop(_))
       .WillOnce(RunClosure());
 
   InitializePipeline(PIPELINE_ERROR_URL_NOT_FOUND);
-  EXPECT_FALSE(pipeline_->IsInitialized());
 }
 
 TEST_F(PipelineTest, NoStreams) {
   EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
       .WillOnce(RunPipelineStatusCB());
   EXPECT_CALL(*mocks_->demuxer(), Stop(_))
       .WillOnce(RunClosure());
 
   InitializePipeline(PIPELINE_ERROR_COULD_NOT_RENDER);
-  EXPECT_FALSE(pipeline_->IsInitialized());
 }
 
 TEST_F(PipelineTest, AudioStream) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
   InitializeDemuxer(&streams);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_TRUE(pipeline_->HasAudio());
   EXPECT_FALSE(pipeline_->HasVideo());
 }
 
 TEST_F(PipelineTest, VideoStream) {
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams);
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_FALSE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 }
 
 TEST_F(PipelineTest, AudioVideoStream) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_TRUE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 }
 
 TEST_F(PipelineTest, Seek) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
@@ skipping 35 matching lines @@
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
   InitializeDemuxer(&streams, kDuration);
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_EQ(kDuration.ToInternalValue(),
             pipeline_->GetMediaDuration().ToInternalValue());
   EXPECT_EQ(kTotalBytes, pipeline_->GetTotalBytes());
   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);
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(pipeline_->IsInitialized());
 
   EXPECT_EQ(0u, pipeline_->GetBufferedTimeRanges().size());
 
   EXPECT_FALSE(pipeline_->DidLoadingProgress());
   pipeline_->AddBufferedByteRange(0, kTotalBytes / 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));
@@ skipping 35 matching lines @@
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_TRUE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 
   EXPECT_CALL(*mocks_->demuxer(), OnAudioRendererDisabled());
   pipeline_->OnAudioDisabled();
 
   // Verify that ended event is fired when video ends.
   EXPECT_CALL(callbacks_, OnEnded(PIPELINE_OK));
   pipeline_->OnVideoRendererEnded();
 }
 
 TEST_F(PipelineTest, DisableAudioRendererDuringInit) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer(true);
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   EXPECT_CALL(*mocks_->demuxer(),
               OnAudioRendererDisabled());
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_FALSE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 
   // Verify that ended event is fired when video ends.
   EXPECT_CALL(callbacks_, OnEnded(PIPELINE_OK));
   pipeline_->OnVideoRendererEnded();
 }
 
 TEST_F(PipelineTest, EndedCallback) {
   CreateAudioStream();
@@ skipping 174 matching lines @@
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
   InitializeDemuxer(&streams, kDuration);
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_FALSE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 
   EXPECT_EQ(base::TimeDelta(), pipeline_->GetMediaTime());
 }
 
 TEST_F(PipelineTest, StartTimeIsNonZero) {
   const base::TimeDelta kStartTime = base::TimeDelta::FromSeconds(4);
   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
 
   EXPECT_CALL(*mocks_->demuxer(), GetStartTime())
       .WillRepeatedly(Return(kStartTime));
 
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams, kDuration);
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_FALSE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 
   EXPECT_EQ(kStartTime, pipeline_->GetMediaTime());
 }
 
 static void RunTimeCB(const AudioRenderer::TimeCB& time_cb,
                        int time_in_ms,
                        int max_time_in_ms) {
   time_cb.Run(base::TimeDelta::FromMilliseconds(time_in_ms),
@@ skipping 53 matching lines @@
   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);
-  EXPECT_FALSE(pipeline_->IsInitialized());
 }
 
 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_->IsInitialized());
   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_FALSE(pipeline_->IsInitialized());
   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_FALSE(pipeline_->IsInitialized());
   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());
@@ skipping 10 matching lines @@
         .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_FALSE(pipeline_->IsInitialized());
   EXPECT_TRUE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 }
 
 class FlexibleCallbackRunner : public base::DelegateSimpleThread::Delegate {
  public:
   FlexibleCallbackRunner(base::TimeDelta delay, PipelineStatus status,
                          const PipelineStatusCB& status_cb)
       : delay_(delay),
         status_(status),
@@ skipping 257 matching lines @@
 INSTANTIATE_TEARDOWN_TEST(Stop, Playing);
 
 INSTANTIATE_TEARDOWN_TEST(Error, Pausing);
 INSTANTIATE_TEARDOWN_TEST(Error, Flushing);
 INSTANTIATE_TEARDOWN_TEST(Error, Seeking);
 INSTANTIATE_TEARDOWN_TEST(Error, Prerolling);
 INSTANTIATE_TEARDOWN_TEST(Error, Starting);
 INSTANTIATE_TEARDOWN_TEST(Error, Playing);
 
 }  // namespace media