Pipeline: Use WeakPtr for DemuxerHost Calls and Tasks.

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/message_loop.h"
 #include "base/stl_util.h"
 #include "base/test/simple_test_tick_clock.h"
@@ skipping 104 matching lines @@
         .WillRepeatedly(Return(base::Time()));
 
     EXPECT_CALL(*demuxer_, GetLiveness())
         .WillRepeatedly(Return(Demuxer::LIVENESS_UNKNOWN));
   }
 
   virtual ~PipelineTest() {
     if (!pipeline_ || !pipeline_->IsRunning())
       return;
 
-    ExpectStop();
+    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.
-    EXPECT_CALL(callbacks_, OnStop());
+    ExpectPipelineStopAndDestroyPipeline();
     pipeline_->Stop(base::Bind(&CallbackHelper::OnStop,
                                base::Unretained(&callbacks_)));
     message_loop_.RunUntilIdle();
   }
 
   void OnDemuxerError() {
     // Cast because OnDemuxerError is private in Pipeline.
     static_cast<DemuxerHost*>(pipeline_.get())
         ->OnDemuxerError(PIPELINE_ERROR_ABORT);
   }
@@ skipping 161 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_.RunUntilIdle();
     EXPECT_EQ(seek_time, pipeline_->GetMediaTime());
   }
 
-  void ExpectStop() {
+  void DestroyPipeline() {
+    pipeline_.reset();
+  }
+
+  void ExpectDemuxerStop() {
     if (demuxer_)
       EXPECT_CALL(*demuxer_, Stop(_)).WillOnce(RunClosure<0>());
   }
 
+  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, &PipelineTest::DestroyPipeline));
+  }
+
   MOCK_METHOD2(OnAddTextTrack, void(const TextTrackConfig&,
                                     const AddTextTrackDoneCB&));
 
   void DoOnAddTextTrack(const TextTrackConfig& config,
                         const AddTextTrackDoneCB& done_cb) {
     scoped_ptr<TextTrack> text_track(new MockTextTrack);
     done_cb.Run(text_track.Pass());
   }
 
   // Fixture members.
@@ skipping 70 matching lines @@
   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(PipelineTest, StopWithoutStart) {
-  EXPECT_CALL(callbacks_, OnStop());
+  ExpectPipelineStopAndDestroyPipeline();
   pipeline_->Stop(
       base::Bind(&CallbackHelper::OnStop, base::Unretained(&callbacks_)));
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(PipelineTest, StartThenStopImmediately) {
   EXPECT_CALL(*demuxer_, Initialize(_, _, _))
       .WillOnce(RunCallback<1>(PIPELINE_OK));
   EXPECT_CALL(*demuxer_, Stop(_))
       .WillOnce(RunClosure<0>());
 
   EXPECT_CALL(callbacks_, OnStart(_));
 
   pipeline_->Start(
       filter_collection_.Pass(),
       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_)));
 
   // Expect a stop callback if we were started.
-  EXPECT_CALL(callbacks_, OnStop());
+  ExpectPipelineStopAndDestroyPipeline();
   pipeline_->Stop(
       base::Bind(&CallbackHelper::OnStop, base::Unretained(&callbacks_)));
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(PipelineTest, DemuxerErrorDuringStop) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
   SetDemuxerExpectations(&streams);
   SetAudioRendererExpectations(audio_stream());
 
   StartPipeline(PIPELINE_OK);
 
   EXPECT_CALL(*demuxer_, Stop(_))
       .WillOnce(DoAll(InvokeWithoutArgs(this, &PipelineTest::OnDemuxerError),
                       RunClosure<0>()));
-  EXPECT_CALL(callbacks_, OnStop());
+  ExpectPipelineStopAndDestroyPipeline();
 
   pipeline_->Stop(
       base::Bind(&CallbackHelper::OnStop, base::Unretained(&callbacks_)));
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(PipelineTest, URLNotFound) {
   EXPECT_CALL(*demuxer_, Initialize(_, _, _))
       .WillOnce(RunCallback<1>(PIPELINE_ERROR_URL_NOT_FOUND));
   EXPECT_CALL(*demuxer_, Stop(_))
@@ skipping 416 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);
 }
 
-static void DeletePipeline(scoped_ptr<Pipeline> pipeline) {
-  // |pipeline| will go out of scope.
-}
-
-TEST_F(PipelineTest, DeleteAfterStop) {
+TEST_F(PipelineTest, DestroyAfterStop) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   SetDemuxerExpectations(&streams);
   SetAudioRendererExpectations(audio_stream());
   StartPipeline(PIPELINE_OK);
 
-  ExpectStop();
+  ExpectDemuxerStop();
 
-  Pipeline* pipeline = pipeline_.get();
-  pipeline->Stop(base::Bind(&DeletePipeline, base::Passed(&pipeline_)));
+  ExpectPipelineStopAndDestroyPipeline();
+  pipeline_->Stop(
+      base::Bind(&CallbackHelper::OnStop, base::Unretained(&callbacks_)));
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(PipelineTest, Underflow) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
@@ skipping 32 matching lines @@
 
   // Double post here! This is a hack to simulate the case where TimeCB is
   // posted during ~AudioRenderer(), which is triggered in Pipeline::DoStop.
   // Since we can't EXPECT_CALL the dtor and Pipeline::DoStop() is posted
   // as well, we need to post twice here.
   message_loop_.PostTask(
       FROM_HERE, base::Bind(&PostTimeCB, &message_loop_, audio_time_cb_));
 
   EXPECT_CALL(*demuxer_, Stop(_)).WillOnce(RunClosure<0>());
 
-  Pipeline* pipeline = pipeline_.get();
-  pipeline->Stop(base::Bind(&DeletePipeline, base::Passed(&pipeline_)));
+  ExpectPipelineStopAndDestroyPipeline();
+  pipeline_->Stop(
+      base::Bind(&CallbackHelper::OnStop, base::Unretained(&callbacks_)));
   message_loop_.RunUntilIdle();
 }
 
 class PipelineTeardownTest : public PipelineTest {
  public:
   enum TeardownState {
     kInitDemuxer,
     kInitAudioRenderer,
     kInitVideoRenderer,
     kFlushing,
@@ skipping 57 matching lines @@
                                            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(*demuxer_, Initialize(_, _, _))
             .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
                             RunCallback<1>(PIPELINE_OK)));
-        EXPECT_CALL(callbacks_, OnStop());
+        ExpectPipelineStopAndDestroyPipeline();
       } else {
         status = DEMUXER_ERROR_COULD_NOT_OPEN;
         EXPECT_CALL(*demuxer_, Initialize(_, _, _))
             .WillOnce(RunCallback<1>(status));
       }
 
       EXPECT_CALL(*demuxer_, Stop(_)).WillOnce(RunClosure<0>());
       return status;
     }
 
     CreateAudioStream();
     CreateVideoStream();
     MockDemuxerStreamVector streams;
     streams.push_back(audio_stream());
     streams.push_back(video_stream());
     SetDemuxerExpectations(&streams, base::TimeDelta::FromSeconds(3000));
 
     if (state == kInitAudioRenderer) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*audio_renderer_, Initialize(_, _, _, _, _, _, _))
             .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
                             RunCallback<1>(PIPELINE_OK)));
-        EXPECT_CALL(callbacks_, OnStop());
+        ExpectPipelineStopAndDestroyPipeline();
       } else {
         status = PIPELINE_ERROR_INITIALIZATION_FAILED;
         EXPECT_CALL(*audio_renderer_, Initialize(_, _, _, _, _, _, _))
             .WillOnce(RunCallback<1>(status));
       }
 
       EXPECT_CALL(*demuxer_, Stop(_)).WillOnce(RunClosure<0>());
       return status;
     }
 
     EXPECT_CALL(*audio_renderer_, Initialize(_, _, _, _, _, _, _))
         .WillOnce(DoAll(SaveArg<4>(&audio_buffering_state_cb_),
                         RunCallback<1>(PIPELINE_OK)));
 
     if (state == kInitVideoRenderer) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*video_renderer_, Initialize(_, _, _, _, _, _, _, _, _, _))
             .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
                             RunCallback<2>(PIPELINE_OK)));
-        EXPECT_CALL(callbacks_, OnStop());
+        ExpectPipelineStopAndDestroyPipeline();
       } else {
         status = PIPELINE_ERROR_INITIALIZATION_FAILED;
         EXPECT_CALL(*video_renderer_, Initialize(_, _, _, _, _, _, _, _, _, _))
             .WillOnce(RunCallback<2>(status));
       }
 
       EXPECT_CALL(*demuxer_, Stop(_)).WillOnce(RunClosure<0>());
       return status;
     }
 
@@ skipping 24 matching lines @@
   }
 
   void DoSeek(TeardownState state, StopOrError stop_or_error) {
     InSequence s;
     PipelineStatus status = SetSeekExpectations(state, stop_or_error);
 
     EXPECT_CALL(*demuxer_, Stop(_)).WillOnce(RunClosure<0>());
     EXPECT_CALL(callbacks_, OnSeek(status));
 
     if (status == PIPELINE_OK) {
-      EXPECT_CALL(callbacks_, OnStop());
+      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;
@@ skipping 48 matching lines @@
     return status;
   }
 
   void DoStopOrError(StopOrError stop_or_error) {
     InSequence s;
 
     EXPECT_CALL(*demuxer_, Stop(_)).WillOnce(RunClosure<0>());
 
     switch (stop_or_error) {
       case kStop:
-        EXPECT_CALL(callbacks_, OnStop());
+        ExpectPipelineStopAndDestroyPipeline();
         pipeline_->Stop(base::Bind(
             &CallbackHelper::OnStop, base::Unretained(&callbacks_)));
         break;
 
       case kError:
         EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_READ));
         pipeline_->SetErrorForTesting(PIPELINE_ERROR_READ);
         break;
 
       case kErrorAndStop:
         EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_READ));
-        EXPECT_CALL(callbacks_, OnStop());
+        ExpectPipelineStopAndDestroyPipeline();
         pipeline_->SetErrorForTesting(PIPELINE_ERROR_READ);
         pipeline_->Stop(base::Bind(
             &CallbackHelper::OnStop, base::Unretained(&callbacks_)));
         break;
     }
 
     message_loop_.RunUntilIdle();
   }
 
   DISALLOW_COPY_AND_ASSIGN(PipelineTeardownTest);
@@ skipping 14 matching lines @@
 INSTANTIATE_TEARDOWN_TEST(Error, InitDemuxer);
 INSTANTIATE_TEARDOWN_TEST(Error, InitAudioRenderer);
 INSTANTIATE_TEARDOWN_TEST(Error, InitVideoRenderer);
 INSTANTIATE_TEARDOWN_TEST(Error, Flushing);
 INSTANTIATE_TEARDOWN_TEST(Error, Seeking);
 INSTANTIATE_TEARDOWN_TEST(Error, Playing);
 
 INSTANTIATE_TEARDOWN_TEST(ErrorAndStop, Playing);
 
 }  // namespace media