Add a lot of Pipeline tests to cover stopping/error handling while in a variety of states.

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"
 #include "media/base/clock.h"
 #include "media/base/media_log.h"
 #include "media/base/pipeline.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_filters.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/size.h"
 
 using ::testing::_;
 using ::testing::DeleteArg;
 using ::testing::DoAll;
 using ::testing::InSequence;

[Ami GONE FROM CHROMIUM, 2012/08/08 17:21:08]

TODO(scherkus): drop InSequence from this file.

 using ::testing::Invoke;
 using ::testing::InvokeWithoutArgs;
 using ::testing::Mock;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::ReturnRef;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 using ::testing::WithArg;
 
 namespace media {
 
 // Demuxer properties.
 static const int kTotalBytes = 1024;
 static const int kBitrate = 1234;
 
 ACTION_P(SetDemuxerProperties, duration) {
   arg0->SetTotalBytes(kTotalBytes);
   arg0->SetDuration(duration);
 }
 
+ACTION_P2(Stop, pipeline, stop_cb) {
+  pipeline->Stop(stop_cb);
+}
+
+ACTION_P2(SetError, pipeline, status) {
+  pipeline->SetErrorForTesting(status);
+}
+
 ACTION(RunPipelineStatusCB1) {

[Ami GONE FROM CHROMIUM, 2012/08/08 17:21:08]

FWIW, this is a dup of RunPipelineStatusCB in mock_filters.h.

[scherkus (not reviewing), 2012/08/08 22:14:29]

you're living in the past, man!!! see http://crrev.com/147619

   arg1.Run(PIPELINE_OK);
 }
 
 ACTION_P(RunPipelineStatusCB1WithStatus, status) {
   arg1.Run(status);
 }
 
 // Used for setting expectations on pipeline callbacks.  Using a StrictMock
 // also lets us test for missing callbacks.
 class CallbackHelper {
@@ skipping 36 matching lines @@
   virtual ~PipelineTest() {
     if (!pipeline_->IsRunning()) {
       return;
     }
 
     // Shutdown sequence.
     if (pipeline_->IsInitialized()) {
       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());
         EXPECT_CALL(*mocks_->audio_renderer(), Stop(_))
             .WillOnce(RunClosure());
       }
 
       if (video_stream_) {
@@ skipping 165 matching lines @@
     pipeline_->Seek(seek_time,
                     base::Bind(&CallbackHelper::OnSeek,
                                base::Unretained(&callbacks_)));
 
     // We expect the time to be updated only after the seek has completed.
     EXPECT_NE(seek_time, pipeline_->GetMediaTime());
     message_loop_.RunAllPending();
     EXPECT_EQ(seek_time, pipeline_->GetMediaTime());
   }
 
+  void SetupShutdownTest() {

[Ami GONE FROM CHROMIUM, 2012/08/08 17:21:08]

I can't tell from this impl, nor from the name, what this function has to do
with shutdown.

[scherkus (not reviewing), 2012/08/08 22:14:29]

Done.

+    CreateAudioStream();
+    MockDemuxerStreamVector streams;
+    streams.push_back(audio_stream());
+
+    InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(3000));
+    InitializeAudioDecoder(audio_stream());
+    InitializeAudioRenderer();
+    InitializePipeline(PIPELINE_OK);
+  }
+
   // Fixture members.
   StrictMock<CallbackHelper> callbacks_;
   MessageLoop message_loop_;
   scoped_refptr<Pipeline> pipeline_;
   scoped_ptr<media::MockFilterCollection> mocks_;
   scoped_refptr<StrictMock<MockDemuxerStream> > audio_stream_;
   scoped_refptr<StrictMock<MockDemuxerStream> > video_stream_;
   AudioRenderer::TimeCB audio_time_cb_;
 
  private:
@@ skipping 161 matching lines @@
 
   // Initialize then seek!
   InitializePipeline(PIPELINE_OK);
 
   // Every filter should receive a call to Seek().
   base::TimeDelta expected = base::TimeDelta::FromSeconds(2000);
   ExpectSeek(expected);
   DoSeek(expected);
 }
 
+TEST_F(PipelineTest, Stop_DuringStart) {
+  base::Closure stop_cb = base::Bind(
+      &CallbackHelper::OnStop, base::Unretained(&callbacks_));
+
+  EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
+      .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunPipelineStatusCB1()));
+
+  // Stop sequence.
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_))
+      .WillOnce(RunClosure());
+  EXPECT_CALL(callbacks_, OnStop());
+
+  InitializePipeline(PIPELINE_OK);
+}
+
+TEST_F(PipelineTest, Stop_DuringPause) {

[Ami GONE FROM CHROMIUM, 2012/08/08 17:21:08]

Stop_During{Pause,Flush,Seek} look like they can be seriously de-duped.

+  SetupShutdownTest();
+  base::Closure stop_cb = base::Bind(
+      &CallbackHelper::OnStop, base::Unretained(&callbacks_));
+
+  InSequence s;
+  EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
+      .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure()));
+
+  // We complete seeks before stopping.
+  // TODO(scherkus): We should be able to stop in any state.
+  EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->demuxer(), Seek(_, _))
+      .WillOnce(RunPipelineStatusCB1());
+  EXPECT_CALL(*mocks_->audio_renderer(), Preroll(_, _))
+      .WillOnce(RunPipelineStatusCB1());
+  EXPECT_CALL(*mocks_->audio_renderer(), Play(_)).WillOnce(RunClosure());
+  EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
+
+  // Stop sequence.
+  // TODO(scherkus): Don't pause+flush on shutdown, see http://crbug.com/110228
+  EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+  EXPECT_CALL(callbacks_, OnStop());
+
+  pipeline_->Seek(base::TimeDelta::FromSeconds(10), base::Bind(
+      &CallbackHelper::OnSeek, base::Unretained(&callbacks_)));
+  message_loop_.RunAllPending();
+}
+
+TEST_F(PipelineTest, Stop_DuringFlush) {
+  SetupShutdownTest();
+  base::Closure stop_cb = base::Bind(
+      &CallbackHelper::OnStop, base::Unretained(&callbacks_));
+
+  InSequence s;
+  EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
+      .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure()));
+
+  // We complete seeks before stopping.
+  // TODO(scherkus): We should be able to stop in any state.
+  EXPECT_CALL(*mocks_->demuxer(), Seek(_, _))
+      .WillOnce(RunPipelineStatusCB1());
+  EXPECT_CALL(*mocks_->audio_renderer(), Preroll(_, _))
+      .WillOnce(RunPipelineStatusCB1());
+  EXPECT_CALL(*mocks_->audio_renderer(), Play(_)).WillOnce(RunClosure());
+  EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
+
+  // Stop sequence.
+  // TODO(scherkus): Don't pause+flush on shutdown, see http://crbug.com/110228
+  EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+  EXPECT_CALL(callbacks_, OnStop());
+
+  pipeline_->Seek(base::TimeDelta::FromSeconds(10), base::Bind(
+      &CallbackHelper::OnSeek, base::Unretained(&callbacks_)));
+  message_loop_.RunAllPending();
+}
+
+TEST_F(PipelineTest, Stop_DuringSeek) {
+  SetupShutdownTest();
+  base::Closure stop_cb = base::Bind(
+      &CallbackHelper::OnStop, base::Unretained(&callbacks_));
+
+  InSequence s;
+  EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->demuxer(), Seek(_, _))
+      .WillOnce(DoAll(Stop(pipeline_, stop_cb),
+                      RunPipelineStatusCB1WithStatus(PIPELINE_OK)));
+
+  // We complete seeks before stopping.
+  // TODO(scherkus): We should be able to stop in any state.
+  EXPECT_CALL(*mocks_->audio_renderer(), Preroll(_, _))
+      .WillOnce(RunPipelineStatusCB1());
+  EXPECT_CALL(*mocks_->audio_renderer(), Play(_)).WillOnce(RunClosure());
+  EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
+
+  // Stop sequence.
+  // TODO(scherkus): Don't pause+flush on shutdown, see http://crbug.com/110228
+  EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+  EXPECT_CALL(callbacks_, OnStop());
+
+  pipeline_->Seek(base::TimeDelta::FromSeconds(10), base::Bind(
+      &CallbackHelper::OnSeek, base::Unretained(&callbacks_)));
+  message_loop_.RunAllPending();
+}
+
+TEST_F(PipelineTest, Stop_DuringPlayback) {
+  SetupShutdownTest();
+
+  InSequence s;
+
+  // Stop sequence.
+  // TODO(scherkus): Don't pause+flush on shutdown, see http://crbug.com/110228

[Ami GONE FROM CHROMIUM, 2012/08/08 17:21:08]

Can you pull out this stanza into a helper ExpectPauseFlushStopDance()?

+  EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+  EXPECT_CALL(callbacks_, OnStop());
+
+  pipeline_->Stop(base::Bind(
+      &CallbackHelper::OnStop, base::Unretained(&callbacks_)));
+  message_loop_.RunAllPending();
+}
+
+TEST_F(PipelineTest, Error_DuringStart) {
+  EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
+      .WillOnce(RunPipelineStatusCB1WithStatus(PIPELINE_ERROR_READ));
+
+  // Stop sequence.
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_))
+      .WillOnce(RunClosure());
+
+  // Start callback should fire with error but nothing else.
+  InitializePipeline(PIPELINE_ERROR_READ);
+}
+
+TEST_F(PipelineTest, Error_DuringPause) {
+  SetupShutdownTest();
+
+  InSequence s;
+  EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
+      .WillOnce(DoAll(SetError(pipeline_, PIPELINE_ERROR_READ), RunClosure()));
+
+  EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
+
+  // Stop sequence.
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+
+  pipeline_->Seek(base::TimeDelta::FromSeconds(10), base::Bind(
+      &CallbackHelper::OnSeek, base::Unretained(&callbacks_)));
+  message_loop_.RunAllPending();
+}
+
+TEST_F(PipelineTest, Error_DuringFlush) {
+  SetupShutdownTest();
+
+  InSequence s;
+  EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
+      .WillOnce(DoAll(SetError(pipeline_, PIPELINE_ERROR_READ), RunClosure()));
+
+  EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
+
+  // Stop sequence.
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+
+  pipeline_->Seek(base::TimeDelta::FromSeconds(10), base::Bind(
+      &CallbackHelper::OnSeek, base::Unretained(&callbacks_)));
+  message_loop_.RunAllPending();
+}
+
+TEST_F(PipelineTest, Error_DuringSeek) {
+  SetupShutdownTest();
+
+  InSequence s;
+  EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->demuxer(), Seek(_, _))
+      .WillOnce(RunPipelineStatusCB1WithStatus(PIPELINE_ERROR_READ));
+
+  EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
+
+  // Stop sequence.
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+
+  pipeline_->Seek(base::TimeDelta::FromSeconds(10), base::Bind(
+      &CallbackHelper::OnSeek, base::Unretained(&callbacks_)));
+  message_loop_.RunAllPending();
+}
+
+TEST_F(PipelineTest, Error_DuringPlayback) {
+  SetupShutdownTest();
+
+  InSequence s;
+
+  // Stop sequence.
+  // TODO(scherkus): Don't pause+flush on shutdown, see http://crbug.com/110228
+  EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+
+  EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_READ));
+
+  pipeline_->SetErrorForTesting(PIPELINE_ERROR_READ);
+  message_loop_.RunAllPending();
+}
+
+TEST_F(PipelineTest, Error_DuringStop) {
+  SetupShutdownTest();
+
+  InSequence s;
+
+  // Stop sequence.
+  // TODO(scherkus): Don't pause+flush on shutdown, see http://crbug.com/110228
+  EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_))
+      .WillOnce(DoAll(SetError(pipeline_, PIPELINE_ERROR_READ), RunClosure()));
+  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+
+  // No error callback should fire.
+  EXPECT_CALL(callbacks_, OnStop());
+
+  pipeline_->Stop(base::Bind(
+      &CallbackHelper::OnStop, base::Unretained(&callbacks_)));
+  message_loop_.RunAllPending();
+}
+
 TEST_F(PipelineTest, SetVolume) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
   InitializeDemuxer(&streams);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
 
   // The audio renderer should receive a call to SetVolume().
@@ skipping 474 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