Fold Pipeline initialization failure tests added in r150636 into PipelineTeardownTest.

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 860 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(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,
                          const PipelineStatusCB& status_cb)
       : delay_(delay),
         status_(status),
         status_cb_(status_cb) {
     if (delay_ < base::TimeDelta()) {
       status_cb_.Run(status_);
       return;
@@ skipping 36 matching lines @@
 
 // Test that different-thread, some-delay callback (the expected common case)
 // works correctly.
 TEST(PipelineStatusNotificationTest, DelayedCallback) {
   TestPipelineStatusNotification(base::TimeDelta::FromMilliseconds(20));
 }
 
 class PipelineTeardownTest : public PipelineTest {
  public:
   enum TeardownState {
+    kInitDemuxer,
+    kInitAudioDecoder,
+    kInitAudioRenderer,
+    kInitVideoDecoder,
+    kInitVideoRenderer,
     kPausing,
     kFlushing,
     kSeeking,
     kPrerolling,
     kStarting,
     kPlaying,
   };
 
   enum StopOrError {
     kStop,
     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:
+        ExpectInitializeTeardown(state, stop_or_error);
+        break;
+
       case kPausing:
       case kFlushing:
       case kSeeking:
       case kPrerolling:
-      case kStarting:
+      case kStarting: {
+        DoInitialize();
+
+        InSequence s;

[acolwell GONE FROM CHROMIUM, 2012/08/10 17:13:08]

Why did this need to move to here ane below?

[scherkus (not reviewing), 2012/08/10 17:35:55]

DoInitialize() / ExpectInitializeTeardown() aren't set up to use InSequence

I'm not a fan of InSequence (brittle tests) but it's required at the moment to
set expectations for the pause-flush-stop shutdown sequence :|

         if (stop_or_error == kStop) {
           ExpectSeekStop(state);
         } else {
           ExpectSeekError(state);
         }
         DoSeek();
         break;
+      }
 
-      case kPlaying:
+      case kPlaying: {
+        DoInitialize();
+
+        InSequence s;
         if (stop_or_error == kStop) {
           ExpectStop();
           DoStop();
         } else {
           ExpectPlaybackError();
           DoPlaybackError();
         }
         break;
+      }
     }
   }
 
  private:
+  void DoInitialize() {
+    CreateAudioStream();
+    MockDemuxerStreamVector streams;
+    streams.push_back(audio_stream());
+
+    InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(3000));
+    InitializeAudioDecoder(audio_stream());
+    InitializeAudioRenderer();
+    InitializePipeline(PIPELINE_OK);
+  }
+
   // 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 ExpectInitializeTeardown(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) {

[acolwell GONE FROM CHROMIUM, 2012/08/10 17:13:08]

nit: remove if and DCHECK_EQ(state, kInitVideoRenderer)? I don't think you
actually want the code past this since DoInitialize() should have been called in
that case. Right?

[scherkus (not reviewing), 2012/08/10 17:35:55]

True! My initial plan for this function was to use it instead of DoInitialize()
but that would have required changing all the seek teardown tests to account for
a video decoder+renderer.

I just went ahead w/ my original plan because I'm actually interested in how we
handle stop/error with two streams involved.

+      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_->audio_renderer(), SetVolume(1.0f));
+    EXPECT_CALL(*mocks_->audio_renderer(), Preroll(base::TimeDelta(), _))
+        .WillOnce(RunPipelineStatusCB());
+    EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
+        .WillOnce(RunClosure());
+
+    return status;
+  }
+
   void ExpectSeekStop(TeardownState state) {
     base::Closure stop_cb = base::Bind(
         &CallbackHelper::OnStop, base::Unretained(&callbacks_));
 
     if (state == kPausing) {
       EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
           .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure()));
     } else {
       EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
     }
@@ skipping 126 matching lines @@
   }
 
   DISALLOW_COPY_AND_ASSIGN(PipelineTeardownTest);
 };
 
 #define INSTANTIATE_TEARDOWN_TEST(stop_or_error, state) \
     TEST_F(PipelineTeardownTest, stop_or_error##_##state) { \
       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);
 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);
 INSTANTIATE_TEARDOWN_TEST(Error, Prerolling);
 INSTANTIATE_TEARDOWN_TEST(Error, Starting);
 INSTANTIATE_TEARDOWN_TEST(Error, Playing);
 
 }  // namespace media