Remove reference counting from media::Demuxer and friends.

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 67 matching lines @@
 // 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 PipelineTest : public ::testing::Test {
  public:
   PipelineTest()
       : pipeline_(new Pipeline(message_loop_.message_loop_proxy(),
                                new MediaLog())),
         filter_collection_(new FilterCollection()) {
     demuxer_ = new MockDemuxer();
-    filter_collection_->SetDemuxer(demuxer_);
+    scoped_ptr<Demuxer> demuxer(demuxer_);
+    filter_collection_->SetDemuxer(demuxer.Pass());
 
     video_renderer_ = new MockVideoRenderer();
     scoped_ptr<VideoRenderer> video_renderer(video_renderer_);
     filter_collection_->SetVideoRenderer(video_renderer.Pass());
 
     audio_renderer_ = new MockAudioRenderer();
     scoped_ptr<AudioRenderer> audio_renderer(audio_renderer_);
     filter_collection_->SetAudioRenderer(audio_renderer.Pass());
 
     // InitializeDemuxer() adds overriding expectations for expected non-NULL
@@ skipping 36 matching lines @@
   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),
                         RunCallback<1>(PIPELINE_OK)));
 
     // Configure the demuxer to return the streams.
     for (size_t i = 0; i < streams->size(); ++i) {
-      scoped_refptr<DemuxerStream> stream((*streams)[i]);
+      DemuxerStream* stream = (*streams)[i];
       EXPECT_CALL(*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>();
+  scoped_ptr<StrictMock<MockDemuxerStream> > CreateStream(
+      DemuxerStream::Type type) {
+    scoped_ptr<StrictMock<MockDemuxerStream> > stream(
+        new StrictMock<MockDemuxerStream>());
     EXPECT_CALL(*stream, type())
         .WillRepeatedly(Return(type));
-    return stream;
+    return stream.Pass();
   }
 
   // Sets up expectations to allow the video renderer to initialize.
-  void InitializeVideoRenderer(const scoped_refptr<DemuxerStream>& stream) {
+  void InitializeVideoRenderer(DemuxerStream* stream) {
     EXPECT_CALL(*video_renderer_, Initialize(stream, _, _, _, _, _, _, _, _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
     EXPECT_CALL(*video_renderer_, SetPlaybackRate(0.0f));
 
     // Startup sequence.
     EXPECT_CALL(*video_renderer_, Preroll(demuxer_->GetStartTime(), _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
     EXPECT_CALL(*video_renderer_, Play(_))
         .WillOnce(RunClosure<0>());
   }
 
   // Sets up expectations to allow the audio renderer to initialize.
-  void InitializeAudioRenderer(const scoped_refptr<DemuxerStream>& stream,
+  void InitializeAudioRenderer(DemuxerStream* stream,
                                bool disable_after_init_cb) {
     if (disable_after_init_cb) {
       EXPECT_CALL(*audio_renderer_, Initialize(stream, _, _, _, _, _, _, _))
           .WillOnce(DoAll(RunCallback<1>(PIPELINE_OK),
                           WithArg<6>(RunClosure<0>())));  // |disabled_cb|.
     } else {
       EXPECT_CALL(*audio_renderer_, Initialize(stream, _, _, _, _, _, _, _))
           .WillOnce(DoAll(SaveArg<4>(&audio_time_cb_),
                           RunCallback<1>(PIPELINE_OK)));
     }
@@ skipping 37 matching lines @@
     audio_stream_ = CreateStream(DemuxerStream::AUDIO);
   }
 
   void CreateVideoStream() {
     video_stream_ = CreateStream(DemuxerStream::VIDEO);
     EXPECT_CALL(*video_stream_, video_decoder_config())
         .WillRepeatedly(ReturnRef(video_decoder_config_));
   }
 
   MockDemuxerStream* audio_stream() {
-    return audio_stream_;
+    return audio_stream_.get();
   }
 
   MockDemuxerStream* video_stream() {
-    return video_stream_;
+    return video_stream_.get();
   }
 
   void ExpectSeek(const base::TimeDelta& seek_time) {
     // Every filter should receive a call to Seek().
     EXPECT_CALL(*demuxer_, Seek(seek_time, _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
     EXPECT_CALL(*demuxer_, SetPlaybackRate(_));
 
     if (audio_stream_) {
       EXPECT_CALL(*audio_renderer_, Pause(_))
@@ skipping 37 matching lines @@
     EXPECT_EQ(seek_time, pipeline_->GetMediaTime());
   }
 
   // Fixture members.
   StrictMock<CallbackHelper> callbacks_;
   base::SimpleTestClock test_clock_;
   MessageLoop message_loop_;
   scoped_refptr<Pipeline> pipeline_;
 
   scoped_ptr<FilterCollection> filter_collection_;
-  scoped_refptr<MockDemuxer> demuxer_;
+  MockDemuxer* demuxer_;
   MockVideoRenderer* video_renderer_;
   MockAudioRenderer* audio_renderer_;
-  scoped_refptr<StrictMock<MockDemuxerStream> > audio_stream_;
-  scoped_refptr<StrictMock<MockDemuxerStream> > video_stream_;
+  scoped_ptr<StrictMock<MockDemuxerStream> > audio_stream_;
+  scoped_ptr<StrictMock<MockDemuxerStream> > video_stream_;
   AudioRenderer::TimeCB audio_time_cb_;
   VideoDecoderConfig video_decoder_config_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PipelineTest);
 };
 
 // Test that playback controls methods no-op when the pipeline hasn't been
 // started.
 TEST_F(PipelineTest, NotStarted) {
@@ skipping 895 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