Move Pipeline permanent callbacks into Pipeline::Client interface.

media/base/pipeline_impl_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 "media/base/pipeline_impl.h"
 
 #include <stddef.h>
 #include <memory>
 #include <utility>
 #include <vector>
@@ skipping 30 matching lines @@
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 using ::testing::WithArg;
 
 namespace media {
 
 ACTION_P(SetDemuxerProperties, duration) {
   arg0->SetDuration(duration);
 }
 
-ACTION_P2(Stop, pipeline, stop_cb) {
-  pipeline->Stop(stop_cb);
+ACTION_P(Stop, pipeline) {
+  pipeline->Stop();
 }
 
 ACTION_P2(SetError, pipeline, status) {
   pipeline->SetErrorForTesting(status);
 }
 
 ACTION_P2(SetBufferingState, cb, buffering_state) {
   cb->Run(buffering_state);
 }
 
 ACTION_TEMPLATE(PostCallback,
                 HAS_1_TEMPLATE_PARAMS(int, k),
                 AND_1_VALUE_PARAMS(p0)) {
   return base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(::std::tr1::get<k>(args), p0));
 }
 
 // TODO(scherkus): even though some filters are initialized on separate
 // threads these test aren't flaky... why?  It's because filters' Initialize()
 // is executed on |message_loop_| and the mock filters instantly call
 // InitializationComplete(), which keeps the pipeline humming along.  If
 // either filters don't call InitializationComplete() immediately or filter
 // initialization is moved to a separate thread this test will become flaky.
 class PipelineImplTest : public ::testing::Test {
  public:
   // Used for setting expectations on pipeline callbacks.  Using a StrictMock
   // also lets us test for missing callbacks.
-  class CallbackHelper {
+  class CallbackHelper : public Pipeline::Client {
    public:
     CallbackHelper() {}
     virtual ~CallbackHelper() {}
 
     MOCK_METHOD1(OnStart, void(PipelineStatus));
     MOCK_METHOD1(OnSeek, void(PipelineStatus));
     MOCK_METHOD1(OnSuspend, void(PipelineStatus));
     MOCK_METHOD1(OnResume, void(PipelineStatus));
-    MOCK_METHOD0(OnStop, void());
+
+    // Pipeline::Client overrides.
+    MOCK_METHOD1(OnError, void(PipelineStatus));
     MOCK_METHOD0(OnEnded, void());
-    MOCK_METHOD1(OnError, void(PipelineStatus));
     MOCK_METHOD1(OnMetadata, void(PipelineMetadata));
     MOCK_METHOD1(OnBufferingStateChange, void(BufferingState));
     MOCK_METHOD0(OnDurationChange, void());
+    MOCK_METHOD2(OnAddTextTrack,
+                 void(const TextTrackConfig&, const AddTextTrackDoneCB&));
+    MOCK_METHOD0(OnWaitingForDecryptionKey, void());
 
    private:
     DISALLOW_COPY_AND_ASSIGN(CallbackHelper);
   };
 
   PipelineImplTest()
       : pipeline_(
             new PipelineImpl(message_loop_.task_runner(), new MediaLog())),
         demuxer_(new StrictMock<MockDemuxer>()),
         scoped_renderer_(new StrictMock<MockRenderer>()),
@@ skipping 18 matching lines @@
 
     ExpectDemuxerStop();
 
     // The mock demuxer doesn't stop the fake text track stream,
     // so just stop it manually.
     if (text_stream_) {
       text_stream_->Stop();
       message_loop_.RunUntilIdle();
     }
 
-    // Expect a stop callback if we were started.
-    ExpectPipelineStopAndDestroyPipeline();
-    pipeline_->Stop(
-        base::Bind(&CallbackHelper::OnStop, base::Unretained(&callbacks_)));
     message_loop_.RunUntilIdle();
+    pipeline_->Stop();
+    DestroyPipeline();
   }
 
   void OnDemuxerError() {
     // Cast because OnDemuxerError is private in Pipeline.
     static_cast<DemuxerHost*>(pipeline_.get())
         ->OnDemuxerError(PIPELINE_ERROR_ABORT);
   }
 
  protected:
   // Sets up expectations to allow the demuxer to initialize.
@@ skipping 29 matching lines @@
   void SetRendererExpectations() {
     EXPECT_CALL(*renderer_, Initialize(_, _, _, _, _, _, _))
         .WillOnce(DoAll(SaveArg<2>(&statistics_cb_),
                         SaveArg<3>(&buffering_state_cb_),
                         SaveArg<4>(&ended_cb_), PostCallback<1>(PIPELINE_OK)));
     EXPECT_CALL(*renderer_, HasAudio()).WillRepeatedly(Return(audio_stream()));
     EXPECT_CALL(*renderer_, HasVideo()).WillRepeatedly(Return(video_stream()));
   }
 
   void AddTextStream() {
-    EXPECT_CALL(*this, OnAddTextTrack(_, _))
+    EXPECT_CALL(callbacks_, OnAddTextTrack(_, _))
         .WillOnce(Invoke(this, &PipelineImplTest::DoOnAddTextTrack));
     static_cast<DemuxerHost*>(pipeline_.get())
         ->AddTextStream(text_stream(),
                         TextTrackConfig(kTextSubtitles, "", "", ""));
     message_loop_.RunUntilIdle();
   }
 
   void StartPipeline() {
-    EXPECT_CALL(*this, OnWaitingForDecryptionKey()).Times(0);
+    EXPECT_CALL(callbacks_, OnWaitingForDecryptionKey()).Times(0);
     pipeline_->Start(
-        demuxer_.get(), std::move(scoped_renderer_),
-        base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
-        base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
-        base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)),
-        base::Bind(&CallbackHelper::OnMetadata, base::Unretained(&callbacks_)),
-        base::Bind(&CallbackHelper::OnBufferingStateChange,
-                   base::Unretained(&callbacks_)),
-        base::Bind(&CallbackHelper::OnDurationChange,
-                   base::Unretained(&callbacks_)),
-        base::Bind(&PipelineImplTest::OnAddTextTrack, base::Unretained(this)),
-        base::Bind(&PipelineImplTest::OnWaitingForDecryptionKey,
-                   base::Unretained(this)));
+        demuxer_.get(), std::move(scoped_renderer_), &callbacks_,
+        base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)));
   }
 
   // Sets up expectations on the callback and initializes the pipeline. Called
   // after tests have set expectations any filters they wish to use.
   void StartPipelineAndExpect(PipelineStatus start_status) {
     EXPECT_CALL(callbacks_, OnStart(start_status));
 
     if (start_status == PIPELINE_OK) {
       EXPECT_CALL(callbacks_, OnMetadata(_)).WillOnce(SaveArg<0>(&metadata_));
       EXPECT_CALL(*renderer_, SetPlaybackRate(0.0));
@@ skipping 100 matching lines @@
     // pointers must have been invalidated before the stop callback returns.
     DCHECK(!pipeline_->HasWeakPtrsForTesting());
     pipeline_.reset();
   }
 
   void ExpectDemuxerStop() {
     if (demuxer_)
       EXPECT_CALL(*demuxer_, Stop());
   }
 
-  void ExpectPipelineStopAndDestroyPipeline() {
-    // After the Pipeline is stopped, it could be destroyed any time. Always
-    // destroy the pipeline immediately after OnStop() to test this.
-    EXPECT_CALL(callbacks_, OnStop())
-        .WillOnce(Invoke(this, &PipelineImplTest::DestroyPipeline));
-  }
-
-  MOCK_METHOD2(OnAddTextTrack,
-               void(const TextTrackConfig&, const AddTextTrackDoneCB&));
-  MOCK_METHOD0(OnWaitingForDecryptionKey, void(void));
-
   void DoOnAddTextTrack(const TextTrackConfig& config,
                         const AddTextTrackDoneCB& done_cb) {
     std::unique_ptr<TextTrack> text_track(new MockTextTrack);
     done_cb.Run(std::move(text_track));
   }
 
   void RunBufferedTimeRangesTest(const base::TimeDelta duration) {
     EXPECT_EQ(0u, pipeline_->GetBufferedTimeRanges().size());
     EXPECT_FALSE(pipeline_->DidLoadingProgress());
     Ranges<base::TimeDelta> ranges;
@@ skipping 64 matching lines @@
   // This test hangs during initialization by never calling
   // InitializationComplete().  StrictMock<> will ensure that the callback is
   // never executed.
   StartPipeline();
   message_loop_.RunUntilIdle();
 
   // Because our callback will get executed when the test tears down, we'll
   // verify that nothing has been called, then set our expectation for the call
   // made during tear down.
   Mock::VerifyAndClear(&callbacks_);
-  EXPECT_CALL(callbacks_, OnStart(PIPELINE_OK));
 }
 
 TEST_F(PipelineImplTest, StopWithoutStart) {
-  ExpectPipelineStopAndDestroyPipeline();
-  pipeline_->Stop(
-      base::Bind(&CallbackHelper::OnStop, base::Unretained(&callbacks_)));
+  pipeline_->Stop();
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(PipelineImplTest, StartThenStopImmediately) {
   EXPECT_CALL(*demuxer_, Initialize(_, _, _))
       .WillOnce(PostCallback<1>(PIPELINE_OK));
   EXPECT_CALL(*demuxer_, Stop());
+  EXPECT_CALL(callbacks_, OnMetadata(_));
 
   EXPECT_CALL(callbacks_, OnStart(_));
   StartPipeline();
+  message_loop_.RunUntilIdle();
 
-  // Expect a stop callback if we were started.
-  ExpectPipelineStopAndDestroyPipeline();
-  pipeline_->Stop(
-      base::Bind(&CallbackHelper::OnStop, base::Unretained(&callbacks_)));
-  message_loop_.RunUntilIdle();
+  pipeline_->Stop();
 }
 
 TEST_F(PipelineImplTest, DemuxerErrorDuringStop) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
   SetDemuxerExpectations(&streams);
   SetRendererExpectations();
 
   StartPipelineAndExpect(PIPELINE_OK);
+  message_loop_.RunUntilIdle();
 
   EXPECT_CALL(*demuxer_, Stop())
       .WillOnce(InvokeWithoutArgs(this, &PipelineImplTest::OnDemuxerError));
-  ExpectPipelineStopAndDestroyPipeline();
-
-  pipeline_->Stop(
-      base::Bind(&CallbackHelper::OnStop, base::Unretained(&callbacks_)));
-  message_loop_.RunUntilIdle();
+  pipeline_->Stop();
 }
 
 TEST_F(PipelineImplTest, NoStreams) {
   EXPECT_CALL(*demuxer_, Initialize(_, _, _))
       .WillOnce(PostCallback<1>(PIPELINE_OK));
   EXPECT_CALL(*demuxer_, Stop());
   EXPECT_CALL(callbacks_, OnMetadata(_));
 
   StartPipelineAndExpect(PIPELINE_ERROR_COULD_NOT_RENDER);
 }
@@ skipping 159 matching lines @@
   SetDemuxerExpectations(&streams);
   SetRendererExpectations();
 
   // The audio renderer should receive a call to SetVolume().
   float expected = 0.5f;
   EXPECT_CALL(*renderer_, SetVolume(expected));
 
   // Initialize then set volume!
   StartPipelineAndExpect(PIPELINE_OK);
   pipeline_->SetVolume(expected);
+  message_loop_.RunUntilIdle();
 }
 
 TEST_F(PipelineImplTest, Properties) {
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
   SetDemuxerExpectations(&streams, kDuration);
   SetRendererExpectations();
@@ skipping 20 matching lines @@
   ExpectSeek(kSeekTime, false);
   DoSeek(kSeekTime);
 
   EXPECT_FALSE(pipeline_->DidLoadingProgress());
 }
 
 TEST_F(PipelineImplTest, BufferedTimeRangesCanChangeAfterStop) {
   EXPECT_CALL(*demuxer_, Initialize(_, _, _))
       .WillOnce(PostCallback<1>(PIPELINE_OK));
   EXPECT_CALL(*demuxer_, Stop());
-
+  EXPECT_CALL(callbacks_, OnMetadata(_));
   EXPECT_CALL(callbacks_, OnStart(_));
   StartPipeline();
-
-  EXPECT_CALL(callbacks_, OnStop());
-  pipeline_->Stop(
-      base::Bind(&CallbackHelper::OnStop, base::Unretained(&callbacks_)));
   message_loop_.RunUntilIdle();
 
+  pipeline_->Stop();
   RunBufferedTimeRangesTest(base::TimeDelta::FromSeconds(5));
   DestroyPipeline();
 }
 
 TEST_F(PipelineImplTest, EndedCallback) {
   CreateAudioStream();
   CreateVideoStream();
   CreateTextStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
@@ skipping 101 matching lines @@
 
 TEST_F(PipelineImplTest, DestroyAfterStop) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   SetDemuxerExpectations(&streams);
   SetRendererExpectations();
   StartPipelineAndExpect(PIPELINE_OK);
 
   ExpectDemuxerStop();
-
-  ExpectPipelineStopAndDestroyPipeline();
-  pipeline_->Stop(
-      base::Bind(&CallbackHelper::OnStop, base::Unretained(&callbacks_)));
+  pipeline_->Stop();
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(PipelineImplTest, Underflow) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   SetDemuxerExpectations(&streams);
   SetRendererExpectations();
   StartPipelineAndExpect(PIPELINE_OK);
 
   // Simulate underflow.
   EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
   buffering_state_cb_.Run(BUFFERING_HAVE_NOTHING);
+  message_loop_.RunUntilIdle();
 
   // Seek while underflowed.
   base::TimeDelta expected = base::TimeDelta::FromSeconds(5);
   ExpectSeek(expected, true);
   DoSeek(expected);
 }
 
 TEST_F(PipelineImplTest, PositiveStartTime) {
   start_time_ = base::TimeDelta::FromSeconds(1);
   EXPECT_CALL(*demuxer_, GetStartTime()).WillRepeatedly(Return(start_time_));
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   SetDemuxerExpectations(&streams);
   SetRendererExpectations();
   StartPipelineAndExpect(PIPELINE_OK);
   ExpectDemuxerStop();
-  ExpectPipelineStopAndDestroyPipeline();
-  pipeline_->Stop(
-      base::Bind(&CallbackHelper::OnStop, base::Unretained(&callbacks_)));
+  pipeline_->Stop();
   message_loop_.RunUntilIdle();
 }
 
 class PipelineTeardownTest : public PipelineImplTest {
  public:
   enum TeardownState {
     kInitDemuxer,
     kInitRenderer,
     kFlushing,
     kSeeking,
@@ skipping 37 matching lines @@
         DoSuspend(state, stop_or_error);
         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 DoInitialize(TeardownState state, StopOrError stop_or_error) {
-    PipelineStatus expected_status =
-        SetInitializeExpectations(state, stop_or_error);
-
-    EXPECT_CALL(callbacks_, OnStart(expected_status));
+    SetInitializeExpectations(state, stop_or_error);
     StartPipeline();
     message_loop_.RunUntilIdle();
   }
 
-  PipelineStatus SetInitializeExpectations(TeardownState state,
-                                           StopOrError stop_or_error) {
-    PipelineStatus status = PIPELINE_OK;
-    base::Closure stop_cb =
-        base::Bind(&CallbackHelper::OnStop, base::Unretained(&callbacks_));
-
+  void SetInitializeExpectations(TeardownState state,
+                                 StopOrError stop_or_error) {
     if (state == kInitDemuxer) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*demuxer_, Initialize(_, _, _))
-            .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
-                            PostCallback<1>(PIPELINE_OK)));
-        ExpectPipelineStopAndDestroyPipeline();
+            .WillOnce(
+                DoAll(Stop(pipeline_.get()), PostCallback<1>(PIPELINE_OK)));
+        // Note: OnStart callback is not called after pipeline is stopped.
       } else {
-        status = DEMUXER_ERROR_COULD_NOT_OPEN;
         EXPECT_CALL(*demuxer_, Initialize(_, _, _))
-            .WillOnce(PostCallback<1>(status));
+            .WillOnce(PostCallback<1>(DEMUXER_ERROR_COULD_NOT_OPEN));
+        EXPECT_CALL(callbacks_, OnStart(DEMUXER_ERROR_COULD_NOT_OPEN));
       }
 
       EXPECT_CALL(*demuxer_, Stop());
-      return status;
+      return;
     }
 
     CreateAudioStream();
     CreateVideoStream();
     MockDemuxerStreamVector streams;
     streams.push_back(audio_stream());
     streams.push_back(video_stream());
     SetDemuxerExpectations(&streams, base::TimeDelta::FromSeconds(3000));
 
     EXPECT_CALL(*renderer_, HasAudio()).WillRepeatedly(Return(true));
     EXPECT_CALL(*renderer_, HasVideo()).WillRepeatedly(Return(true));
 
     if (state == kInitRenderer) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*renderer_, Initialize(_, _, _, _, _, _, _))
-            .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
-                            PostCallback<1>(PIPELINE_OK)));
-        ExpectPipelineStopAndDestroyPipeline();
+            .WillOnce(
+                DoAll(Stop(pipeline_.get()), PostCallback<1>(PIPELINE_OK)));
+        // Note: OnStart or OnMetadata callback are not called
+        // after pipeline is stopped.
       } else {
-        status = PIPELINE_ERROR_INITIALIZATION_FAILED;
         EXPECT_CALL(*renderer_, Initialize(_, _, _, _, _, _, _))
-            .WillOnce(PostCallback<1>(status));
+            .WillOnce(PostCallback<1>(PIPELINE_ERROR_INITIALIZATION_FAILED));
+        EXPECT_CALL(callbacks_, OnMetadata(_));
+        EXPECT_CALL(callbacks_, OnStart(PIPELINE_ERROR_INITIALIZATION_FAILED));
       }
 
       EXPECT_CALL(*demuxer_, Stop());
-      EXPECT_CALL(callbacks_, OnMetadata(_));
-      return status;
+      return;
     }
 
     EXPECT_CALL(*renderer_, Initialize(_, _, _, _, _, _, _))
         .WillOnce(DoAll(SaveArg<3>(&buffering_state_cb_),
                         PostCallback<1>(PIPELINE_OK)));
 
+    // If we get here it's a successful initialization.
+    EXPECT_CALL(callbacks_, OnStart(PIPELINE_OK));
     EXPECT_CALL(callbacks_, OnMetadata(_));
 
-    // If we get here it's a successful initialization.
     EXPECT_CALL(*renderer_, SetPlaybackRate(0.0));
     EXPECT_CALL(*renderer_, SetVolume(1.0f));
     EXPECT_CALL(*renderer_, StartPlayingFrom(base::TimeDelta()))
         .WillOnce(
             SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_ENOUGH));
-
-    if (status == PIPELINE_OK)
-      EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
-
-    return status;
+    EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   }
 
   void DoSeek(TeardownState state, StopOrError stop_or_error) {
-    InSequence s;
-    PipelineStatus status = SetSeekExpectations(state, stop_or_error);
+    SetSeekExpectations(state, stop_or_error);
 
     EXPECT_CALL(*demuxer_, Stop());
-    EXPECT_CALL(callbacks_, OnSeek(status));
-
-    if (status == PIPELINE_OK) {
-      ExpectPipelineStopAndDestroyPipeline();
-    }
 
     pipeline_->Seek(
         base::TimeDelta::FromSeconds(10),
         base::Bind(&CallbackHelper::OnSeek, base::Unretained(&callbacks_)));
     message_loop_.RunUntilIdle();
   }
 
-  PipelineStatus SetSeekExpectations(TeardownState state,
-                                     StopOrError stop_or_error) {
-    PipelineStatus status = PIPELINE_OK;
-    base::Closure stop_cb =
-        base::Bind(&CallbackHelper::OnStop, base::Unretained(&callbacks_));
-
+  void SetSeekExpectations(TeardownState state, StopOrError stop_or_error) {
     if (state == kFlushing) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*renderer_, Flush(_))
             .WillOnce(DoAll(
-                Stop(pipeline_.get(), stop_cb),
                 SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_NOTHING),
+                Stop(pipeline_.get()), RunClosure<0>()));
+        // Note: OnBufferingStateChange or OnSeek callbacks are not called
+        // after pipeline is stopped.
+      } else {
+        EXPECT_CALL(*renderer_, Flush(_))
+            .WillOnce(DoAll(
+                SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_NOTHING),
+                SetError(pipeline_.get(), PIPELINE_ERROR_READ),
                 RunClosure<0>()));
         EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
-      } else {
-        status = PIPELINE_ERROR_READ;
-        EXPECT_CALL(*renderer_, Flush(_))
-            .WillOnce(DoAll(
-                SetError(pipeline_.get(), status),
-                SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_NOTHING),
-                RunClosure<0>()));
-        EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
+        EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
       }
-
-      return status;
+      return;
     }
 
     EXPECT_CALL(*renderer_, Flush(_))
         .WillOnce(DoAll(
             SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_NOTHING),
             RunClosure<0>()));
     EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
 
     if (state == kSeeking) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*demuxer_, Seek(_, _))
-            .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
-                            RunCallback<1>(PIPELINE_OK)));
+            .WillOnce(
+                DoAll(Stop(pipeline_.get()), RunCallback<1>(PIPELINE_OK)));
+        // Note: OnSeek callback is not called after pipeline is stopped.
       } else {
-        status = PIPELINE_ERROR_READ;
-        EXPECT_CALL(*demuxer_, Seek(_, _)).WillOnce(RunCallback<1>(status));
+        EXPECT_CALL(*demuxer_, Seek(_, _))
+            .WillOnce(RunCallback<1>(PIPELINE_ERROR_READ));
+        EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
       }
-
-      return status;
+      return;
     }
 
     NOTREACHED() << "State not supported: " << state;
-    return status;
   }
 
   void DoSuspend(TeardownState state, StopOrError stop_or_error) {
-    PipelineStatus status = SetSuspendExpectations(state, stop_or_error);
+    SetSuspendExpectations(state, stop_or_error);
 
     if (state == kResuming) {
       EXPECT_CALL(*demuxer_, Stop());
-      if (status == PIPELINE_OK)
-        ExpectPipelineStopAndDestroyPipeline();
     }
 
     PipelineImplTest::DoSuspend();
 
     if (state == kResuming) {
       PipelineImplTest::DoResume(base::TimeDelta());
       return;
     }
 
     // kSuspended, kSuspending never throw errors, since Resume() is always able
     // to restore the pipeline to a pristine state.
     DoStopOrError(stop_or_error, false);
   }
 
-  PipelineStatus SetSuspendExpectations(TeardownState state,
-                                        StopOrError stop_or_error) {
-    PipelineStatus status = PIPELINE_OK;
-    base::Closure stop_cb =
-        base::Bind(&CallbackHelper::OnStop, base::Unretained(&callbacks_));
-
+  void SetSuspendExpectations(TeardownState state, StopOrError stop_or_error) {
     EXPECT_CALL(*renderer_, SetPlaybackRate(0));
     EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
     EXPECT_CALL(callbacks_, OnSuspend(PIPELINE_OK));
     EXPECT_CALL(*renderer_, Flush(_))
         .WillOnce(DoAll(
             SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_NOTHING),
             RunClosure<0>()));
     if (state == kResuming) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*demuxer_, Seek(_, _))
-            .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
-                            RunCallback<1>(PIPELINE_OK)));
-        EXPECT_CALL(callbacks_, OnResume(PIPELINE_OK));
+            .WillOnce(
+                DoAll(Stop(pipeline_.get()), RunCallback<1>(PIPELINE_OK)));
+        // Note: OnResume callback is not called after pipeline is stopped.
       } else {
-        status = PIPELINE_ERROR_READ;
-        EXPECT_CALL(*demuxer_, Seek(_, _)).WillOnce(RunCallback<1>(status));
-        EXPECT_CALL(callbacks_, OnResume(status));
+        EXPECT_CALL(*demuxer_, Seek(_, _))
+            .WillOnce(RunCallback<1>(PIPELINE_ERROR_READ));
+        EXPECT_CALL(callbacks_, OnResume(PIPELINE_ERROR_READ));
       }
     } else if (state != kSuspended && state != kSuspending) {
       NOTREACHED() << "State not supported: " << state;
     }
-
-    return status;
   }
 
   void DoStopOrError(StopOrError stop_or_error, bool expect_errors) {
     InSequence s;
 
     switch (stop_or_error) {
       case kStop:
         EXPECT_CALL(*demuxer_, Stop());
-        ExpectPipelineStopAndDestroyPipeline();
-        pipeline_->Stop(
-            base::Bind(&CallbackHelper::OnStop, base::Unretained(&callbacks_)));
+        pipeline_->Stop();
         break;
 
       case kError:
         if (expect_errors) {
           EXPECT_CALL(*demuxer_, Stop());
           EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_READ));
         }
         pipeline_->SetErrorForTesting(PIPELINE_ERROR_READ);
         break;
 
       case kErrorAndStop:
         EXPECT_CALL(*demuxer_, Stop());
         if (expect_errors)
           EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_READ));
-        ExpectPipelineStopAndDestroyPipeline();
         pipeline_->SetErrorForTesting(PIPELINE_ERROR_READ);
         message_loop_.RunUntilIdle();
-        pipeline_->Stop(
-            base::Bind(&CallbackHelper::OnStop, base::Unretained(&callbacks_)));
+        pipeline_->Stop();
         break;
     }
 
     message_loop_.RunUntilIdle();
   }
 
   DISALLOW_COPY_AND_ASSIGN(PipelineTeardownTest);
 };
 
 #define INSTANTIATE_TEARDOWN_TEST(stop_or_error, state)   \
@@ skipping 16 matching lines @@
 INSTANTIATE_TEARDOWN_TEST(Error, Seeking);
 INSTANTIATE_TEARDOWN_TEST(Error, Playing);
 INSTANTIATE_TEARDOWN_TEST(Error, Suspending);
 INSTANTIATE_TEARDOWN_TEST(Error, Suspended);
 INSTANTIATE_TEARDOWN_TEST(Error, Resuming);
 
 INSTANTIATE_TEARDOWN_TEST(ErrorAndStop, Playing);
 INSTANTIATE_TEARDOWN_TEST(ErrorAndStop, Suspended);
 
 }  // namespace media