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;
+// TODO(scherkus): Remove InSequence after refactoring Pipeline.
 using ::testing::InSequence;
 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(RunPipelineStatusCB1) {
+ACTION_P2(Stop, pipeline, stop_cb) {
+  pipeline->Stop(stop_cb);
+}
+
+ACTION_P2(SetError, pipeline, status) {
+  pipeline->SetErrorForTesting(status);
+}
+
+ACTION(RunPipelineStatusCB) {
   arg1.Run(PIPELINE_OK);
 }
 
-ACTION_P(RunPipelineStatusCB1WithStatus, status) {
+ACTION_P(RunPipelineStatusCBWithStatus, status) {
   arg1.Run(status);
 }
 
 // Used for setting expectations on pipeline callbacks.  Using a StrictMock
 // also lets us test for missing callbacks.
 class CallbackHelper {
  public:
   CallbackHelper() {}
   virtual ~CallbackHelper() {}
 
@@ skipping 32 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 16 matching lines @@
     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) {
     EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
         .WillOnce(DoAll(SetDemuxerProperties(duration),
-                        RunPipelineStatusCB1()));
+                        RunPipelineStatusCB()));
 
     // 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));
   }
 
   StrictMock<MockDemuxerStream>* CreateStream(DemuxerStream::Type type) {
     StrictMock<MockDemuxerStream>* stream =
         new StrictMock<MockDemuxerStream>();
     EXPECT_CALL(*stream, type())
         .WillRepeatedly(Return(type));
     return stream;
   }
 
   // Sets up expectations to allow the video decoder to initialize.
   void InitializeVideoDecoder(const scoped_refptr<DemuxerStream>& stream) {
     EXPECT_CALL(*mocks_->video_decoder(),
                 Initialize(stream, _, _))
-        .WillOnce(RunPipelineStatusCB1());
+        .WillOnce(RunPipelineStatusCB());
   }
 
   // Sets up expectations to allow the audio decoder to initialize.
   void InitializeAudioDecoder(const scoped_refptr<DemuxerStream>& stream) {
     EXPECT_CALL(*mocks_->audio_decoder(), Initialize(stream, _, _))
-        .WillOnce(RunPipelineStatusCB1());
+        .WillOnce(RunPipelineStatusCB());
   }
 
   // Sets up expectations to allow the video renderer to initialize.
   void InitializeVideoRenderer() {
     EXPECT_CALL(*mocks_->video_renderer(), Initialize(
         scoped_refptr<VideoDecoder>(mocks_->video_decoder()),
         _, _, _, _, _, _, _, _))
-        .WillOnce(RunPipelineStatusCB1());
+        .WillOnce(RunPipelineStatusCB());
     EXPECT_CALL(*mocks_->video_renderer(), SetPlaybackRate(0.0f));
 
     // Startup sequence.
     EXPECT_CALL(*mocks_->video_renderer(),
                 Preroll(mocks_->demuxer()->GetStartTime(), _))
-        .WillOnce(RunPipelineStatusCB1());
+        .WillOnce(RunPipelineStatusCB());
     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) {
     if (disable_after_init_cb) {
       EXPECT_CALL(*mocks_->audio_renderer(), Initialize(
           scoped_refptr<AudioDecoder>(mocks_->audio_decoder()),
           _, _, _, _, _, _))
-          .WillOnce(DoAll(RunPipelineStatusCB1(),
+          .WillOnce(DoAll(RunPipelineStatusCB(),
                           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()));
+                          RunPipelineStatusCB()));
     }
   }
 
   // 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());
+            .WillOnce(RunPipelineStatusCB());
         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_)));
@@ skipping 12 matching lines @@
     return audio_stream_;
   }
 
   MockDemuxerStream* video_stream() {
     return video_stream_;
   }
 
   void ExpectSeek(const base::TimeDelta& seek_time) {
     // Every filter should receive a call to Seek().
     EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, _))
-        .WillOnce(RunPipelineStatusCB1());
+        .WillOnce(RunPipelineStatusCB());
 
     if (audio_stream_) {
       EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
           .WillOnce(RunClosure());
       EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
           .WillOnce(RunClosure());
       EXPECT_CALL(*mocks_->audio_renderer(), Preroll(seek_time, _))
-          .WillOnce(RunPipelineStatusCB1());
+          .WillOnce(RunPipelineStatusCB());
       EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
           .WillOnce(RunClosure());
     }
 
     if (video_stream_) {
       EXPECT_CALL(*mocks_->video_renderer(), Pause(_))
           .WillOnce(RunClosure());
       EXPECT_CALL(*mocks_->video_renderer(), Flush(_))
           .WillOnce(RunClosure());
       EXPECT_CALL(*mocks_->video_renderer(), Preroll(seek_time, _))
-          .WillOnce(RunPipelineStatusCB1());
+          .WillOnce(RunPipelineStatusCB());
       EXPECT_CALL(*mocks_->video_renderer(), Play(_))
           .WillOnce(RunClosure());
     }
 
     // We expect a successful seek callback.
     EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
   }
 
   void DoSeek(const base::TimeDelta& seek_time) {
     pipeline_->Seek(seek_time,
@@ skipping 91 matching lines @@
       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(RunPipelineStatusCB1WithStatus(PIPELINE_ERROR_URL_NOT_FOUND));
+      .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(RunPipelineStatusCB1());
+      .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;
@@ skipping 308 matching lines @@
 
   // Seek() isn't called as the demuxer errors out first.
   EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
       .WillOnce(RunClosure());
   EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
       .WillOnce(RunClosure());
   EXPECT_CALL(*mocks_->audio_renderer(), Stop(_))
       .WillOnce(RunClosure());
 
   EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, _))
-      .WillOnce(RunPipelineStatusCB1WithStatus(PIPELINE_ERROR_READ));
+      .WillOnce(RunPipelineStatusCBWithStatus(PIPELINE_ERROR_READ));
   EXPECT_CALL(*mocks_->demuxer(), Stop(_))
       .WillOnce(RunClosure());
 
   pipeline_->Seek(seek_time, base::Bind(&CallbackHelper::OnSeek,
                                         base::Unretained(&callbacks_)));
   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
   message_loop_.RunAllPending();
 }
 
 // Invoked function OnError. This asserts that the pipeline does not enqueue
@@ skipping 35 matching lines @@
 
   // Seek() isn't called as the demuxer errors out first.
   EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
       .WillOnce(RunClosure());
   EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
       .WillOnce(RunClosure());
   EXPECT_CALL(*mocks_->audio_renderer(), Stop(_))
       .WillOnce(RunClosure());
 
   EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, _))
-      .WillOnce(RunPipelineStatusCB1WithStatus(PIPELINE_ERROR_READ));
+      .WillOnce(RunPipelineStatusCBWithStatus(PIPELINE_ERROR_READ));
   EXPECT_CALL(*mocks_->demuxer(), Stop(_))
       .WillOnce(RunClosure());
 
   pipeline_->Seek(seek_time, base::Bind(&CallbackHelper::OnSeek,
                                         base::Unretained(&callbacks_)));
   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
   message_loop_.RunAllPending();
 }
 
 TEST_F(PipelineTest, StartTimeIsZero) {
@@ skipping 66 matching lines @@
                      base::TimeDelta::FromMilliseconds(500));
 
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(5);
 
   // Arrange to trigger a time update while the demuxer is in the middle of
   // seeking. This update should be ignored by the pipeline and the clock should
   // not get updated.
   base::Closure closure = base::Bind(&RunTimeCB, audio_time_cb_, 300, 700);
   EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&closure, &base::Closure::Run),
-                      RunPipelineStatusCB1()));
+                      RunPipelineStatusCB()));
 
   EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
       .WillOnce(RunClosure());
   EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
       .WillOnce(RunClosure());
   EXPECT_CALL(*mocks_->audio_renderer(), Preroll(seek_time, _))
-      .WillOnce(RunPipelineStatusCB1());
+      .WillOnce(RunPipelineStatusCB());
   EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
       .WillOnce(RunClosure());
 
   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
   DoSeek(seek_time);
 
   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));
+      .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(RunPipelineStatusCB1WithStatus(expected_status));
+      .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(RunPipelineStatusCB1WithStatus(expected_status));
+      .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(RunPipelineStatusCB1WithStatus(expected_status));
+      .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());
 
   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));
+        .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());
@@ skipping 47 matching lines @@
 TEST(PipelineStatusNotificationTest, ImmediateCallback) {
   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));
 }
 
+class PipelineTeardownTest : public PipelineTest {
+ public:
+  enum TeardownState {
+    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);
+  }
+
+  void RunTest(TeardownState state, StopOrError stop_or_error) {
+    InSequence s;
+    switch (state) {
+      case kPausing:
+      case kFlushing:
+      case kSeeking:
+      case kPrerolling:
+      case kStarting:
+        if (stop_or_error == kStop) {
+          ExpectSeekStop(state);
+        } else {
+          ExpectSeekError(state);
+        }
+        DoSeek();
+        break;
+
+      case kPlaying:
+        if (stop_or_error == kStop) {
+          ExpectStop();
+          DoStop();
+        } else {
+          ExpectPlaybackError();
+          DoPlaybackError();
+        }
+        break;
+    }
+  }
+
+ private:
+  // 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 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());
+    }
+
+    if (state == kFlushing) {
+      EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
+          .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure()));
+    } else {
+      EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure());
+    }
+
+    if (state == kSeeking) {
+      EXPECT_CALL(*mocks_->demuxer(), Seek(_, _))
+          .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunPipelineStatusCB()));
+    } else {
+      EXPECT_CALL(*mocks_->demuxer(), Seek(_, _))
+          .WillOnce(RunPipelineStatusCB());
+    }
+
+    if (state == kPrerolling) {
+      EXPECT_CALL(*mocks_->audio_renderer(), Preroll(_, _))
+          .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunPipelineStatusCB()));
+    } else {
+      EXPECT_CALL(*mocks_->audio_renderer(), Preroll(_, _))
+          .WillOnce(RunPipelineStatusCB());
+    }
+
+    if (state == kStarting) {
+      EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
+          .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure()));
+    } else {
+      EXPECT_CALL(*mocks_->audio_renderer(), Play(_)).WillOnce(RunClosure());
+    }
+
+    EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
+    ExpectStop();
+  }
+
+  void ExpectSeekError(TeardownState state) {
+    SetSeekErrorExpectations(state);
+
+    // Executed after the error is raised.
+    EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
+    EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+    EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+  }
+
+  void SetSeekErrorExpectations(TeardownState state) {
+    if (state == kPausing) {
+      EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
+          .WillOnce(DoAll(SetError(pipeline_, PIPELINE_ERROR_READ),
+                          RunClosure()));
+      return;
+    }
+
+    EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
+
+    if (state == kFlushing) {
+      EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
+          .WillOnce(DoAll(SetError(pipeline_, PIPELINE_ERROR_READ),
+                          RunClosure()));
+      return;
+    }
+
+    EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure());
+
+    if (state == kSeeking) {
+      EXPECT_CALL(*mocks_->demuxer(), Seek(_, _))
+          .WillOnce(RunPipelineStatusCBWithStatus(PIPELINE_ERROR_READ));
+      return;
+    }
+
+    EXPECT_CALL(*mocks_->demuxer(), Seek(_, _))
+        .WillOnce(RunPipelineStatusCB());
+
+    if (state == kPrerolling) {
+      EXPECT_CALL(*mocks_->audio_renderer(), Preroll(_, _))
+          .WillOnce(RunPipelineStatusCBWithStatus(PIPELINE_ERROR_READ));
+      return;
+    }
+
+    EXPECT_CALL(*mocks_->audio_renderer(), Preroll(_, _))
+        .WillOnce(RunPipelineStatusCB());
+
+    if (state == kStarting) {
+      EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
+          .WillOnce(DoAll(SetError(pipeline_, PIPELINE_ERROR_READ),
+                          RunClosure()));
+      return;
+    }
+
+    NOTREACHED() << "Unexpected TeardownState: " << state;
+  }
+
+  void ExpectStop() {
+    // TODO(scherkus): Don't pause+flush, 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());
+  }
+
+  void ExpectPlaybackError() {
+    // TODO(scherkus): Don't pause+flush, 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));
+  }
+
+  void DoSeek() {
+    pipeline_->Seek(base::TimeDelta::FromSeconds(10), base::Bind(
+        &CallbackHelper::OnSeek, base::Unretained(&callbacks_)));
+    message_loop_.RunAllPending();
+  }
+
+  void DoStop() {
+    pipeline_->Stop(base::Bind(
+        &CallbackHelper::OnStop, base::Unretained(&callbacks_)));
+    message_loop_.RunAllPending();
+  }
+
+  void DoPlaybackError() {
+    pipeline_->SetErrorForTesting(PIPELINE_ERROR_READ);
+    message_loop_.RunAllPending();
+  }
+
+  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, 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, 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