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 117 matching lines @@
   }
 
  protected:
   // Sets up expectations to allow the demuxer to initialize.
   typedef std::vector<MockDemuxerStream*> MockDemuxerStreamVector;
   void InitializeDemuxer(MockDemuxerStreamVector* streams,
                          const base::TimeDelta& duration) {
     EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
         .WillOnce(DoAll(SetDemuxerProperties(duration),
                         RunPipelineStatusCB1()));
-    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) {
@@ skipping 46 matching lines @@
           _, _, _, _, _, _))
           .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());
   }
 
   // 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));
 
+    if (start_status == PIPELINE_OK) {
+      EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(0.0f));
+
+      if (audio_stream_) {
+        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());
+      }
+    }
+
     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();
   }
 
   void CreateAudioStream() {
     audio_stream_ = CreateStream(DemuxerStream::AUDIO);
@@ skipping 478 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 64 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, 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);
+
+  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);
+  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);
+  InitializeAudioDecoder(audio_stream());
+  InitializeAudioRenderer();
+
+  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());
+}
+
+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(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