Remove reference counting from media::Pipeline.

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/test/simple_test_clock.h"
@@ skipping 107 matching lines @@
         EXPECT_CALL(*video_renderer_, Stop(_))
             .WillOnce(RunClosure<0>());
     }
 
     // Expect a stop callback if we were started.
     EXPECT_CALL(callbacks_, OnStop());
     pipeline_->Stop(base::Bind(&CallbackHelper::OnStop,
                                base::Unretained(&callbacks_)));
     message_loop_.RunUntilIdle();
 
-    pipeline_ = NULL;
     filter_collection_.reset();
+    pipeline_.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(callbacks_, OnDurationChange());
     EXPECT_CALL(*demuxer_, Initialize(_, _))
         .WillOnce(DoAll(SetDemuxerProperties(duration),
@@ skipping 142 matching lines @@
     // 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());
   }
 
   // Fixture members.
   StrictMock<CallbackHelper> callbacks_;
   base::SimpleTestClock test_clock_;
   base::MessageLoop message_loop_;
-  scoped_refptr<Pipeline> pipeline_;
+  scoped_ptr<Pipeline> pipeline_;
 
   scoped_ptr<FilterCollection> filter_collection_;
   scoped_ptr<MockDemuxer> demuxer_;
   MockVideoRenderer* video_renderer_;
   MockAudioRenderer* audio_renderer_;
   scoped_ptr<StrictMock<MockDemuxerStream> > audio_stream_;
   scoped_ptr<StrictMock<MockDemuxerStream> > video_stream_;
   AudioRenderer::TimeCB audio_time_cb_;
   VideoDecoderConfig video_decoder_config_;
 
@@ skipping 401 matching lines @@
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
   InitializeDemuxer(&streams);
   InitializeAudioRenderer(audio_stream(), false);
   InitializePipeline(PIPELINE_OK);
 
   // Trigger additional requests on the pipeline during tear down from error.
   base::Callback<void(PipelineStatus)> cb = base::Bind(
-      &TestNoCallsAfterError, pipeline_, &message_loop_);
+      &TestNoCallsAfterError, pipeline_.get(), &message_loop_);
   ON_CALL(callbacks_, OnError(_))
       .WillByDefault(Invoke(&cb, &base::Callback<void(PipelineStatus)>::Run));
 
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(5);
 
   // Seek() isn't called as the demuxer errors out first.
   EXPECT_CALL(*audio_renderer_, Pause(_))
       .WillOnce(RunClosure<0>());
   EXPECT_CALL(*audio_renderer_, Flush(_))
       .WillOnce(RunClosure<0>());
@@ skipping 180 matching lines @@
 
   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(*demuxer_, Initialize(_, _))
-            .WillOnce(DoAll(Stop(pipeline_, stop_cb),
+            .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
                             RunCallback<1>(PIPELINE_OK)));
         EXPECT_CALL(callbacks_, OnStop());
       } 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());
     InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(3000));
 
     if (state == kInitAudioRenderer) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*audio_renderer_, Initialize(_, _, _, _, _, _, _, _))
-            .WillOnce(DoAll(Stop(pipeline_, stop_cb),
+            .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
                             RunCallback<1>(PIPELINE_OK)));
         EXPECT_CALL(callbacks_, OnStop());
       } else {
         status = PIPELINE_ERROR_INITIALIZATION_FAILED;
         EXPECT_CALL(*audio_renderer_, Initialize(_, _, _, _, _, _, _, _))
             .WillOnce(RunCallback<1>(status));
       }
 
       EXPECT_CALL(*demuxer_, Stop(_)).WillOnce(RunClosure<0>());
       EXPECT_CALL(*audio_renderer_, Stop(_)).WillOnce(RunClosure<0>());
       return status;
     }
 
     EXPECT_CALL(*audio_renderer_, Initialize(_, _, _, _, _, _, _, _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
 
     if (state == kInitVideoRenderer) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*video_renderer_, Initialize(_, _, _, _, _, _, _, _, _))
-            .WillOnce(DoAll(Stop(pipeline_, stop_cb),
+            .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
                             RunCallback<1>(PIPELINE_OK)));
         EXPECT_CALL(callbacks_, OnStop());
       } else {
         status = PIPELINE_ERROR_INITIALIZATION_FAILED;
         EXPECT_CALL(*video_renderer_, Initialize(_, _, _, _, _, _, _, _, _))
             .WillOnce(RunCallback<1>(status));
       }
 
       EXPECT_CALL(*demuxer_, Stop(_)).WillOnce(RunClosure<0>());
       EXPECT_CALL(*audio_renderer_, Stop(_)).WillOnce(RunClosure<0>());
@@ skipping 48 matching lines @@
 
   PipelineStatus SetSeekExpectations(TeardownState state,
                                      StopOrError stop_or_error) {
     PipelineStatus status = PIPELINE_OK;
     base::Closure stop_cb = base::Bind(
         &CallbackHelper::OnStop, base::Unretained(&callbacks_));
 
     if (state == kPausing) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*audio_renderer_, Pause(_))
-            .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure<0>()));
+            .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb), RunClosure<0>()));
       } else {
         status = PIPELINE_ERROR_READ;
-        EXPECT_CALL(*audio_renderer_, Pause(_))
-            .WillOnce(DoAll(SetError(pipeline_, status), RunClosure<0>()));
+        EXPECT_CALL(*audio_renderer_, Pause(_)).WillOnce(
+            DoAll(SetError(pipeline_.get(), status), RunClosure<0>()));
       }
 
       return status;
     }
 
     EXPECT_CALL(*audio_renderer_, Pause(_)).WillOnce(RunClosure<0>());
     EXPECT_CALL(*video_renderer_, Pause(_)).WillOnce(RunClosure<0>());
 
     if (state == kFlushing) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*audio_renderer_, Flush(_))
-            .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure<0>()));
+            .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb), RunClosure<0>()));
       } else {
         status = PIPELINE_ERROR_READ;
-        EXPECT_CALL(*audio_renderer_, Flush(_))
-            .WillOnce(DoAll(SetError(pipeline_, status), RunClosure<0>()));
+        EXPECT_CALL(*audio_renderer_, Flush(_)).WillOnce(
+            DoAll(SetError(pipeline_.get(), status), RunClosure<0>()));
       }
 
       return status;
     }
 
     EXPECT_CALL(*audio_renderer_, Flush(_)).WillOnce(RunClosure<0>());
     EXPECT_CALL(*video_renderer_, Flush(_)).WillOnce(RunClosure<0>());
 
     if (state == kSeeking) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*demuxer_, Seek(_, _))
-            .WillOnce(DoAll(Stop(pipeline_, stop_cb),
+            .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
                             RunCallback<1>(PIPELINE_OK)));
       } else {
         status = PIPELINE_ERROR_READ;
         EXPECT_CALL(*demuxer_, Seek(_, _))
             .WillOnce(RunCallback<1>(status));
       }
 
       return status;
     }
 
     EXPECT_CALL(*demuxer_, Seek(_, _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
 
     if (state == kPrerolling) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*audio_renderer_, Preroll(_, _))
-            .WillOnce(DoAll(Stop(pipeline_, stop_cb),
+            .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
                             RunCallback<1>(PIPELINE_OK)));
       } else {
         status = PIPELINE_ERROR_READ;
         EXPECT_CALL(*audio_renderer_, Preroll(_, _))
             .WillOnce(RunCallback<1>(status));
       }
 
       return status;
     }
 
     EXPECT_CALL(*audio_renderer_, Preroll(_, _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
     EXPECT_CALL(*video_renderer_, Preroll(_, _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
 
     // Playback rate and volume are updated prior to starting.
     EXPECT_CALL(*demuxer_, SetPlaybackRate(0.0f));
     EXPECT_CALL(*audio_renderer_, SetPlaybackRate(0.0f));
     EXPECT_CALL(*video_renderer_, SetPlaybackRate(0.0f));
     EXPECT_CALL(*audio_renderer_, SetVolume(1.0f));
 
     if (state == kStarting) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*audio_renderer_, Play(_))
-            .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure<0>()));
+            .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb), RunClosure<0>()));
       } else {
         status = PIPELINE_ERROR_READ;
-        EXPECT_CALL(*audio_renderer_, Play(_))
-            .WillOnce(DoAll(SetError(pipeline_, status), RunClosure<0>()));
+        EXPECT_CALL(*audio_renderer_, Play(_)).WillOnce(
+            DoAll(SetError(pipeline_.get(), status), RunClosure<0>()));
       }
       return status;
     }
 
     NOTREACHED() << "State not supported: " << state;
     return status;
   }
 
   void DoStopOrError(StopOrError stop_or_error) {
     InSequence s;
@@ skipping 36 matching lines @@
 INSTANTIATE_TEARDOWN_TEST(Error, InitAudioRenderer);
 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