Fix Pipeline to properly handle errors during initialization.

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 113 matching lines @@
     message_loop_.RunAllPending();
 
     pipeline_ = NULL;
     mocks_.reset();
   }
 
  protected:
   // Sets up expectations to allow the demuxer to initialize.
   typedef std::vector<MockDemuxerStream*> MockDemuxerStreamVector;
   void InitializeDemuxer(MockDemuxerStreamVector* streams,
-                         const base::TimeDelta& duration) {
+                         const base::TimeDelta& duration,
+                         bool expect_set_playback_rate) {
     EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
         .WillOnce(DoAll(SetDemuxerProperties(duration),
                         RunPipelineStatusCB1()));
-    EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(0.0f));
+    if (expect_set_playback_rate)

[scherkus (not reviewing), 2012/08/08 21:15:02]

instead of a bool, can this block can get moves to InitializePipeline when
start_status == PIPELINE_OK?

AFAIK it only gets called if everything gets initialized w/o error

[acolwell GONE FROM CHROMIUM, 2012/08/08 21:40:59]

Yes it can. Done.

+      EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(0.0f));
 
     // Configure the demuxer to return the streams.
     for (size_t i = 0; i < streams->size(); ++i) {
       scoped_refptr<DemuxerStream> stream((*streams)[i]);
       EXPECT_CALL(*mocks_->demuxer(), GetStream(stream->type()))
           .WillRepeatedly(Return(stream));
     }
   }
 
   void InitializeDemuxer(MockDemuxerStreamVector* streams) {
     // Initialize with a default non-zero duration.
-    InitializeDemuxer(streams, base::TimeDelta::FromSeconds(10));
+    InitializeDemuxer(streams, base::TimeDelta::FromSeconds(10), true);
+  }
+
+  void InitializeDemuxer(MockDemuxerStreamVector* streams,
+                         bool expect_set_playback_rate) {
+    // Initialize with a default non-zero duration.
+    InitializeDemuxer(streams, base::TimeDelta::FromSeconds(10),
+                      expect_set_playback_rate);
   }
 
   StrictMock<MockDemuxerStream>* CreateStream(DemuxerStream::Type type) {
     StrictMock<MockDemuxerStream>* stream =
         new StrictMock<MockDemuxerStream>();
     EXPECT_CALL(*stream, type())
         .WillRepeatedly(Return(type));
     return stream;
   }
 
@@ skipping 20 matching lines @@
 
     // Startup sequence.
     EXPECT_CALL(*mocks_->video_renderer(),
                 Preroll(mocks_->demuxer()->GetStartTime(), _))
         .WillOnce(RunPipelineStatusCB1());
     EXPECT_CALL(*mocks_->video_renderer(), Play(_))
         .WillOnce(RunClosure());
   }
 
   // Sets up expectations to allow the audio renderer to initialize.
-  void InitializeAudioRenderer(bool disable_after_init_cb = false) {
+  void InitializeAudioRenderer() {
+    InitializeAudioRenderer(false, true);
+  }
+
+  void InitializeAudioRenderer(bool disable_after_init_cb,
+                               bool expect_to_play) {
     if (disable_after_init_cb) {
       EXPECT_CALL(*mocks_->audio_renderer(), Initialize(
           scoped_refptr<AudioDecoder>(mocks_->audio_decoder()),
           _, _, _, _, _, _))
           .WillOnce(DoAll(RunPipelineStatusCB1(),
                           WithArg<5>(RunClosure())));  // |disabled_cb|.
     } else {
       EXPECT_CALL(*mocks_->audio_renderer(), Initialize(
           scoped_refptr<AudioDecoder>(mocks_->audio_decoder()),
           _, _, _, _, _, _))
           .WillOnce(DoAll(SaveArg<3>(&audio_time_cb_),
                           RunPipelineStatusCB1()));
     }
-    EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(0.0f));
-    EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(1.0f));
 
-    // Startup sequence.
-    EXPECT_CALL(*mocks_->audio_renderer(), Preroll(base::TimeDelta(), _))
-        .WillOnce(RunPipelineStatusCB1());
-    EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
-        .WillOnce(RunClosure());
+    if (expect_to_play) {
+      EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(0.0f));

[scherkus (not reviewing), 2012/08/08 21:15:02]

ditto (move to InitializePipeline when start_status == PIPELINE_OK)

[acolwell GONE FROM CHROMIUM, 2012/08/08 21:40:59]

Done.

+      EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(1.0f));
+
+      // Startup sequence.
+      EXPECT_CALL(*mocks_->audio_renderer(), Preroll(base::TimeDelta(), _))
+          .WillOnce(RunPipelineStatusCB1());
+      EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
+          .WillOnce(RunClosure());
+    }
   }
 
   // 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) {
     EXPECT_CALL(callbacks_, OnStart(start_status));
 
     pipeline_->Start(
         mocks_->Create().Pass(),
         base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
@@ skipping 219 matching lines @@
   EXPECT_TRUE(pipeline_->HasVideo());
 }
 
 TEST_F(PipelineTest, Seek) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
-  InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(3000));
+  InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(3000), true);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   // Initialize then seek!
   InitializePipeline(PIPELINE_OK);
 
   // Every filter should receive a call to Seek().
   base::TimeDelta expected = base::TimeDelta::FromSeconds(2000);
@@ skipping 18 matching lines @@
   InitializePipeline(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);
+  InitializeDemuxer(&streams, kDuration, true);
   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);
+  InitializeDemuxer(&streams, kDuration, true);
   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);
@@ skipping 63 matching lines @@
 
 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);
+  InitializeAudioRenderer(true, 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());
@@ skipping 51 matching lines @@
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   // Replace the clock so we can simulate wallclock time advancing w/o using
   // Sleep().
   pipeline_->SetClockForTesting(new Clock(&StaticClockFunction));
 
-  InitializeDemuxer(&streams, duration);
+  InitializeDemuxer(&streams, duration, true);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
   InitializePipeline(PIPELINE_OK);
 
   EXPECT_EQ(0, pipeline_->GetMediaTime().ToInternalValue());
 
   float playback_rate = 1.0f;
   EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(playback_rate));
@@ skipping 32 matching lines @@
       .WillOnce(Return(true));
   EXPECT_CALL(callbacks_, OnEnded(PIPELINE_OK));
   pipeline_->OnRendererEnded();
 }
 
 TEST_F(PipelineTest, ErrorDuringSeek) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
-  InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(10));
+  InitializeDemuxer(&streams);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializePipeline(PIPELINE_OK);
 
   float playback_rate = 1.0f;
   EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(playback_rate));
   EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(playback_rate));
   pipeline_->SetPlaybackRate(playback_rate);
   message_loop_.RunAllPending();
 
@@ skipping 35 matching lines @@
 
   // No additional tasks should be queued as a result of these calls.
   message_loop->AssertIdle();
 }
 
 TEST_F(PipelineTest, NoMessageDuringTearDownFromError) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
-  InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(10));
+  InitializeDemuxer(&streams);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializePipeline(PIPELINE_OK);
 
   // Trigger additional requests on the pipeline during tear down from error.
   base::Callback<void(PipelineStatus)> cb = base::Bind(
       &TestNoCallsAfterError, pipeline_, &message_loop_);
   ON_CALL(callbacks_, OnError(_))
       .WillByDefault(Invoke(&cb, &base::Callback<void(PipelineStatus)>::Run));
 
@@ skipping 17 matching lines @@
   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
   message_loop_.RunAllPending();
 }
 
 TEST_F(PipelineTest, StartTimeIsZero) {
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
-  InitializeDemuxer(&streams, kDuration);
+  InitializeDemuxer(&streams, kDuration, true);
   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);
+  InitializeDemuxer(&streams, kDuration, true);
   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),
               base::TimeDelta::FromMilliseconds(max_time_in_ms));
 }
 
 TEST_F(PipelineTest, AudioTimeUpdateDuringSeek) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
-  InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(10));
+  InitializeDemuxer(&streams);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializePipeline(PIPELINE_OK);
 
   float playback_rate = 1.0f;
   EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(playback_rate));
   EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(playback_rate));
   pipeline_->SetPlaybackRate(playback_rate);
   message_loop_.RunAllPending();
 
@@ skipping 27 matching lines @@
   EXPECT_EQ(pipeline_->GetMediaTime(), seek_time);
 
   // Now that the seek is complete, verify that time updates advance the current
   // time.
   base::TimeDelta new_time = seek_time + base::TimeDelta::FromMilliseconds(100);
   audio_time_cb_.Run(new_time, new_time);
 
   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(RunPipelineStatusCB1WithStatus(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, false);
+
+  PipelineStatus expected_status = PIPELINE_ERROR_DECODE;
+  scoped_refptr<DemuxerStream> stream = streams[0];
+  EXPECT_CALL(*mocks_->audio_decoder(), Initialize(stream, _, _))
+      .WillOnce(RunPipelineStatusCB1WithStatus(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, false);
+  InitializeAudioDecoder(audio_stream());
+
+  PipelineStatus expected_status = PIPELINE_ERROR_INITIALIZATION_FAILED;
+  EXPECT_CALL(*mocks_->audio_renderer(), Initialize(
+      scoped_refptr<AudioDecoder>(mocks_->audio_decoder()),
+      _, _, _, _, _, _))
+      .WillOnce(RunPipelineStatusCB1WithStatus(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, false);
+  InitializeAudioDecoder(audio_stream());
+  InitializeAudioRenderer(false, false);
+
+  PipelineStatus expected_status = PIPELINE_ERROR_DECODE;
+  scoped_refptr<DemuxerStream> stream = streams[1];
+  EXPECT_CALL(*mocks_->video_decoder(),
+              Initialize(stream, _, _))
+      .WillOnce(RunPipelineStatusCB1WithStatus(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());
+}
+

[scherkus (not reviewing), 2012/08/08 21:15:02]

remove extra blank line

[acolwell GONE FROM CHROMIUM, 2012/08/08 21:40:59]

Done.

+
+TEST_F(PipelineTest, InitFailure_VideoRenderer) {
+  CreateAudioStream();
+  CreateVideoStream();
+  MockDemuxerStreamVector streams;
+  streams.push_back(audio_stream());
+  streams.push_back(video_stream());
+
+  InitializeDemuxer(&streams, false);
+  InitializeAudioDecoder(audio_stream());
+  InitializeAudioRenderer(false, false);
+  InitializeVideoDecoder(video_stream());
+
+  PipelineStatus expected_status = PIPELINE_ERROR_INITIALIZATION_FAILED;
+  EXPECT_CALL(*mocks_->video_renderer(), Initialize(
+        scoped_refptr<VideoDecoder>(mocks_->video_decoder()),
+        _, _, _, _, _, _, _, _))
+        .WillOnce(RunPipelineStatusCB1WithStatus(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),
         status_cb_(status_cb) {
     if (delay_ < base::TimeDelta()) {
       status_cb_.Run(status_);
       return;
@@ skipping 34 matching lines @@
   TestPipelineStatusNotification(base::TimeDelta::FromMilliseconds(0));
 }
 
 // Test that different-thread, some-delay callback (the expected common case)
 // works correctly.
 TEST(PipelineStatusNotificationTest, DelayedCallback) {
   TestPipelineStatusNotification(base::TimeDelta::FromMilliseconds(20));
 }
 
 }  // namespace media