Remove reference counting from media::Demuxer and friends.

media/filters/chunk_demuxer_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 <algorithm>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.h"
@@ skipping 134 matching lines @@
 
   ChunkDemuxerTest() {
     CreateNewDemuxer();
   }
 
   void CreateNewDemuxer() {
     base::Closure open_cb =
         base::Bind(&ChunkDemuxerTest::DemuxerOpened, base::Unretained(this));
     ChunkDemuxer::NeedKeyCB need_key_cb =
         base::Bind(&ChunkDemuxerTest::DemuxerNeedKey, base::Unretained(this));
-    demuxer_ = new ChunkDemuxer(open_cb, need_key_cb, LogCB());
+    demuxer_.reset(new ChunkDemuxer(open_cb, need_key_cb, LogCB()));
   }
 
   virtual ~ChunkDemuxerTest() {
     ShutdownDemuxer();
   }
 
   void CreateInitSegment(bool has_audio, bool has_video,
                          bool is_audio_encrypted, bool is_video_encrypted,
                          scoped_ptr<uint8[]>* buffer,
                          int* size) {
@@ skipping 389 matching lines @@
       AddVideoBlockGroup(&cb, track_number, timecode, block_duration,
                          kWebMFlagKeyframe);
     } else {
       cb.AddBlockGroup(track_number, timecode, block_duration,
                        kWebMFlagKeyframe, data.get(), size);
     }
     return cb.Finish();
   }
 
   void Read(DemuxerStream::Type type, const DemuxerStream::ReadCB& read_cb) {
-    scoped_refptr<DemuxerStream> stream = demuxer_->GetStream(type);
-    stream->Read(read_cb);
+    demuxer_->GetStream(type)->Read(read_cb);
     message_loop_.RunUntilIdle();
   }
 
   void ReadAudio(const DemuxerStream::ReadCB& read_cb) {
     Read(DemuxerStream::AUDIO, read_cb);
   }
 
   void ReadVideo(const DemuxerStream::ReadCB& read_cb) {
     Read(DemuxerStream::VIDEO, read_cb);
   }
@@ skipping 95 matching lines @@
     do {
       stream->Read(base::Bind(&ChunkDemuxerTest::StoreStatusAndBuffer,
                               base::Unretained(this), status, &buffer));
       MessageLoop::current()->RunUntilIdle();
       if (*status == DemuxerStream::kOk && !buffer->IsEndOfStream())
         *last_timestamp = buffer->GetTimestamp();
     } while (*status == DemuxerStream::kOk && !buffer->IsEndOfStream());
   }
 
   void ExpectEndOfStream(DemuxerStream::Type type) {
-    scoped_refptr<DemuxerStream> stream = demuxer_->GetStream(type);
     EXPECT_CALL(*this, ReadDone(DemuxerStream::kOk, IsEndOfStream()));
-    stream->Read(base::Bind(&ChunkDemuxerTest::ReadDone,
-                            base::Unretained(this)));
+    demuxer_->GetStream(type)->Read(base::Bind(
+        &ChunkDemuxerTest::ReadDone, base::Unretained(this)));
     message_loop_.RunUntilIdle();
   }
 
   void ExpectRead(DemuxerStream::Type type, int64 timestamp_in_ms) {
-    scoped_refptr<DemuxerStream> stream = demuxer_->GetStream(type);
     EXPECT_CALL(*this, ReadDone(DemuxerStream::kOk,
                                 HasTimestamp(timestamp_in_ms)));
-    stream->Read(base::Bind(&ChunkDemuxerTest::ReadDone,
-                            base::Unretained(this)));
+    demuxer_->GetStream(type)->Read(base::Bind(
+        &ChunkDemuxerTest::ReadDone, base::Unretained(this)));
     message_loop_.RunUntilIdle();
   }
 
   void ExpectConfigChanged(DemuxerStream::Type type) {
-    scoped_refptr<DemuxerStream> stream = demuxer_->GetStream(type);
     EXPECT_CALL(*this, ReadDone(DemuxerStream::kConfigChanged, _));
-    stream->Read(base::Bind(&ChunkDemuxerTest::ReadDone,
-                            base::Unretained(this)));
+    demuxer_->GetStream(type)->Read(base::Bind(
+        &ChunkDemuxerTest::ReadDone, base::Unretained(this)));
     message_loop_.RunUntilIdle();
   }
 
   MOCK_METHOD1(Checkpoint, void(int id));
 
   struct BufferTimestamps {
     int video_time_ms;
     int audio_time_ms;
   };
   static const int kSkip = -1;
@@ skipping 62 matching lines @@
   MOCK_METHOD3(NeedKeyMock, void(const std::string& type,
                                  const uint8* init_data, int init_data_size));
   void DemuxerNeedKey(const std::string& type,
                       scoped_ptr<uint8[]> init_data, int init_data_size) {
     NeedKeyMock(type, init_data.get(), init_data_size);
   }
 
   MessageLoop message_loop_;
   MockDemuxerHost host_;
 
-  scoped_refptr<ChunkDemuxer> demuxer_;
+  scoped_ptr<ChunkDemuxer> demuxer_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChunkDemuxerTest);
 };
 
 TEST_F(ChunkDemuxerTest, TestInit) {
   // Test no streams, audio-only, video-only, and audio & video scenarios.
   // Audio and video streams can be encrypted or not encrypted.
   for (int i = 0; i < 16; i++) {
     bool has_audio = (i & 0x1) != 0;
@@ skipping 43 matching lines @@
         demuxer_->GetStream(DemuxerStream::VIDEO);
     if (has_video) {
       EXPECT_TRUE(video_stream);
       EXPECT_EQ(is_video_encrypted,
                 video_stream->video_decoder_config().is_encrypted());
     } else {
       EXPECT_FALSE(video_stream);
     }
 
     ShutdownDemuxer();
-    demuxer_ = NULL;
+    demuxer_.reset();
   }
 }
 
 // Make sure that the demuxer reports an error if Shutdown()
 // is called before all the initialization segments are appended.
 TEST_F(ChunkDemuxerTest, TestShutdownBeforeAllInitSegmentsAppended) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(
           kDefaultDuration(), DEMUXER_ERROR_COULD_NOT_OPEN));
@@ skipping 223 matching lines @@
   demuxer_->Initialize(
       &host_, NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN));
 
   ASSERT_EQ(AddId(), ChunkDemuxer::kOk);
 
   CheckExpectedRanges("{ }");
   demuxer_->EndOfStream(PIPELINE_OK);
   ShutdownDemuxer();
   CheckExpectedRanges("{ }");
   demuxer_->RemoveId(kSourceId);
-  demuxer_ = NULL;
+  demuxer_.reset();
 }
 
 TEST_F(ChunkDemuxerTest, TestEndOfStreamWithNoMediaAppend) {
   ASSERT_TRUE(InitDemuxer(true, true));
 
   CheckExpectedRanges("{ }");
   demuxer_->EndOfStream(PIPELINE_OK);
   CheckExpectedRanges("{ }");
 }
 
@@ skipping 17 matching lines @@
   CheckExpectedRanges(kDefaultFirstClusterRange);
 
   EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_NETWORK));
   demuxer_->EndOfStream(PIPELINE_ERROR_NETWORK);
 }
 
 // Helper class to reduce duplicate code when testing end of stream
 // Read() behavior.
 class EndOfStreamHelper {
  public:
-  explicit EndOfStreamHelper(const scoped_refptr<Demuxer> demuxer)
+  explicit EndOfStreamHelper(Demuxer* demuxer)
       : demuxer_(demuxer),
         audio_read_done_(false),
         video_read_done_(false) {
   }
 
   // Request a read on the audio and video streams.
   void RequestReads() {
     EXPECT_FALSE(audio_read_done_);
     EXPECT_FALSE(video_read_done_);
 
@@ skipping 17 matching lines @@
  private:
   static void OnEndOfStreamReadDone(
       bool* called,
       DemuxerStream::Status status,
       const scoped_refptr<DecoderBuffer>& buffer) {
     EXPECT_EQ(status, DemuxerStream::kOk);
     EXPECT_TRUE(buffer->IsEndOfStream());
     *called = true;
   }
 
-  scoped_refptr<Demuxer> demuxer_;
+  Demuxer* demuxer_;
   bool audio_read_done_;
   bool video_read_done_;
 
   DISALLOW_COPY_AND_ASSIGN(EndOfStreamHelper);
 };
 
 // Make sure that all pending reads that we don't have media data for get an
 // "end of stream" buffer when EndOfStream() is called.
 TEST_F(ChunkDemuxerTest, TestEndOfStreamWithPendingReads) {
   ASSERT_TRUE(InitDemuxer(true, true));
 
   scoped_ptr<Cluster> cluster(GenerateCluster(0, 2));
   AppendData(cluster->data(), cluster->size());
 
   bool audio_read_done_1 = false;
   bool video_read_done_1 = false;
-  EndOfStreamHelper end_of_stream_helper_1(demuxer_);
-  EndOfStreamHelper end_of_stream_helper_2(demuxer_);
+  EndOfStreamHelper end_of_stream_helper_1(demuxer_.get());
+  EndOfStreamHelper end_of_stream_helper_2(demuxer_.get());
 
   ReadAudio(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(0),
                        &audio_read_done_1));
   ReadVideo(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(0),
                        &video_read_done_1));
 
   end_of_stream_helper_1.RequestReads();
   end_of_stream_helper_2.RequestReads();
@@ skipping 14 matching lines @@
 // Make sure that all Read() calls after we get an EndOfStream()
 // call return an "end of stream" buffer.
 TEST_F(ChunkDemuxerTest, TestReadsAfterEndOfStream) {
   ASSERT_TRUE(InitDemuxer(true, true));
 
   scoped_ptr<Cluster> cluster(GenerateCluster(0, 2));
   AppendData(cluster->data(), cluster->size());
 
   bool audio_read_done_1 = false;
   bool video_read_done_1 = false;
-  EndOfStreamHelper end_of_stream_helper_1(demuxer_);
-  EndOfStreamHelper end_of_stream_helper_2(demuxer_);
-  EndOfStreamHelper end_of_stream_helper_3(demuxer_);
+  EndOfStreamHelper end_of_stream_helper_1(demuxer_.get());
+  EndOfStreamHelper end_of_stream_helper_2(demuxer_.get());
+  EndOfStreamHelper end_of_stream_helper_3(demuxer_.get());
 
   ReadAudio(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(0),
                        &audio_read_done_1));
   ReadVideo(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(0),
                        &video_read_done_1));
 
   end_of_stream_helper_1.RequestReads();
 
@@ skipping 882 matching lines @@
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(kDefaultSecondClusterEndTimestamp)));
   demuxer_->EndOfStream(PIPELINE_OK);
 
   demuxer_->Seek(base::TimeDelta::FromSeconds(0),
                  NewExpectedStatusCB(PIPELINE_OK));
 
   GenerateExpectedReads(0, 4);
   GenerateExpectedReads(46, 66, 5);
 
-  EndOfStreamHelper end_of_stream_helper(demuxer_);
+  EndOfStreamHelper end_of_stream_helper(demuxer_.get());
   end_of_stream_helper.RequestReads();
   end_of_stream_helper.CheckIfReadDonesWereCalled(true);
 }
 
 TEST_F(ChunkDemuxerTest, TestConfigChange_Video) {
   InSequence s;
 
   ASSERT_TRUE(InitDemuxerWithConfigChangeData());
 
   DemuxerStream::Status status;
@@ skipping 40 matching lines @@
 }
 
 TEST_F(ChunkDemuxerTest, TestConfigChange_Audio) {
   InSequence s;
 
   ASSERT_TRUE(InitDemuxerWithConfigChangeData());
 
   DemuxerStream::Status status;
   base::TimeDelta last_timestamp;
 
-    scoped_refptr<DemuxerStream> audio =
+  scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
 
   // Fetch initial audio config and verify it matches what we expect.
   const AudioDecoderConfig& audio_config_1 = audio->audio_decoder_config();
   ASSERT_TRUE(audio_config_1.IsValidConfig());
   EXPECT_EQ(audio_config_1.samples_per_second(), 44100);
   EXPECT_EQ(audio_config_1.extra_data_size(), 3863u);
 
   ExpectRead(DemuxerStream::AUDIO, 0);
 
@@ skipping 250 matching lines @@
 // call. This can happen if video element gets destroyed before
 // the pipeline has a chance to initialize the demuxer.
 TEST_F(ChunkDemuxerTest, TestShutdownBeforeInitialize) {
   demuxer_->Shutdown();
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(DEMUXER_ERROR_COULD_NOT_OPEN));
   message_loop_.RunUntilIdle();
 }
 
 }  // namespace media