Remove reference counting from media::DemuxerStream 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 646 matching lines @@
                             scoped_refptr<DecoderBuffer>* buffer_out,
                             DemuxerStream::Status status,
                             const scoped_refptr<DecoderBuffer>& buffer) {
     *status_out = status;
     *buffer_out = buffer;
   }
 
   void ReadUntilNotOkOrEndOfStream(DemuxerStream::Type type,
                                    DemuxerStream::Status* status,
                                    base::TimeDelta* last_timestamp) {
-    scoped_refptr<DemuxerStream> stream = demuxer_->GetStream(type);
+    DemuxerStream* stream = demuxer_->GetStream(type);
     scoped_refptr<DecoderBuffer> buffer;
 
     *last_timestamp = kNoTimestamp();
     do {
       stream->Read(base::Bind(&ChunkDemuxerTest::StoreStatusAndBuffer,
                               base::Unretained(this), status, &buffer));
       base::MessageLoop::current()->RunUntilIdle();
       if (*status == DemuxerStream::kOk && !buffer->IsEndOfStream())
         *last_timestamp = buffer->GetTimestamp();
     } while (*status == DemuxerStream::kOk && !buffer->IsEndOfStream());
@@ skipping 127 matching lines @@
       int need_key_count = (is_audio_encrypted ? 1 : 0) +
                            (is_video_encrypted ? 1 : 0);
       EXPECT_CALL(*this, NeedKeyMock(kWebMEncryptInitDataType, NotNull(),
                                      DecryptConfig::kDecryptionKeySize))
           .Times(Exactly(need_key_count));
     }
 
     ASSERT_TRUE(InitDemuxerWithEncryptionInfo(
         has_audio, has_video, is_audio_encrypted, is_video_encrypted));
 
-    scoped_refptr<DemuxerStream> audio_stream =
-        demuxer_->GetStream(DemuxerStream::AUDIO);
+    DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
     if (has_audio) {
       ASSERT_TRUE(audio_stream);
 
       const AudioDecoderConfig& config = audio_stream->audio_decoder_config();
       EXPECT_EQ(kCodecVorbis, config.codec());
       EXPECT_EQ(32, config.bits_per_channel());
       EXPECT_EQ(CHANNEL_LAYOUT_STEREO, config.channel_layout());
       EXPECT_EQ(44100, config.samples_per_second());
       EXPECT_TRUE(config.extra_data());
       EXPECT_GT(config.extra_data_size(), 0u);
       EXPECT_EQ(kSampleFormatPlanarF32, config.sample_format());
       EXPECT_EQ(is_audio_encrypted,
                 audio_stream->audio_decoder_config().is_encrypted());
     } else {
       EXPECT_FALSE(audio_stream);
     }
 
-    scoped_refptr<DemuxerStream> video_stream =
-        demuxer_->GetStream(DemuxerStream::VIDEO);
+    DemuxerStream* video_stream = 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_.reset();
@@ skipping 282 matching lines @@
       : 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_);
 
-    scoped_refptr<DemuxerStream> audio =
-        demuxer_->GetStream(DemuxerStream::AUDIO);
-    scoped_refptr<DemuxerStream> video =
-        demuxer_->GetStream(DemuxerStream::VIDEO);
+    DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
+    DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
 
     audio->Read(base::Bind(&OnEndOfStreamReadDone, &audio_read_done_));
     video->Read(base::Bind(&OnEndOfStreamReadDone, &video_read_done_));
     base::MessageLoop::current()->RunUntilIdle();
   }
 
   // Check to see if |audio_read_done_| and |video_read_done_| variables
   // match |expected|.
   void CheckIfReadDonesWereCalled(bool expected) {
     EXPECT_EQ(expected, audio_read_done_);
@@ skipping 974 matching lines @@
 }
 
 TEST_F(ChunkDemuxerTest, TestConfigChange_Video) {
   InSequence s;
 
   ASSERT_TRUE(InitDemuxerWithConfigChangeData());
 
   DemuxerStream::Status status;
   base::TimeDelta last_timestamp;
 
-  scoped_refptr<DemuxerStream> video =
-      demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
 
   // Fetch initial video config and verify it matches what we expect.
   const VideoDecoderConfig& video_config_1 = video->video_decoder_config();
   ASSERT_TRUE(video_config_1.IsValidConfig());
   EXPECT_EQ(video_config_1.natural_size().width(), 320);
   EXPECT_EQ(video_config_1.natural_size().height(), 240);
 
   ExpectRead(DemuxerStream::VIDEO, 0);
 
   ReadUntilNotOkOrEndOfStream(DemuxerStream::VIDEO, &status, &last_timestamp);
@@ skipping 26 matching lines @@
 }
 
 TEST_F(ChunkDemuxerTest, TestConfigChange_Audio) {
   InSequence s;
 
   ASSERT_TRUE(InitDemuxerWithConfigChangeData());
 
   DemuxerStream::Status status;
   base::TimeDelta last_timestamp;
 
-  scoped_refptr<DemuxerStream> audio =
-      demuxer_->GetStream(DemuxerStream::AUDIO);
+  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);
 
   ReadUntilNotOkOrEndOfStream(DemuxerStream::AUDIO, &status, &last_timestamp);
@@ skipping 23 matching lines @@
   // config changes.
   ReadUntilNotOkOrEndOfStream(DemuxerStream::AUDIO, &status, &last_timestamp);
   ASSERT_EQ(status, DemuxerStream::kOk);
 }
 
 TEST_F(ChunkDemuxerTest, TestConfigChange_Seek) {
   InSequence s;
 
   ASSERT_TRUE(InitDemuxerWithConfigChangeData());
 
-  scoped_refptr<DemuxerStream> video =
-      demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
 
   // Fetch initial video config and verify it matches what we expect.
   const VideoDecoderConfig& video_config_1 = video->video_decoder_config();
   ASSERT_TRUE(video_config_1.IsValidConfig());
   EXPECT_EQ(video_config_1.natural_size().width(), 320);
   EXPECT_EQ(video_config_1.natural_size().height(), 240);
 
   ExpectRead(DemuxerStream::VIDEO, 0);
 
   // Seek to a location with a different config.
@@ skipping 203 matching lines @@
 // Test receiving a Shutdown() call before we get an Initialize()
 // 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();
 }
 
+TEST_F(ChunkDemuxerTest, ReadAfterAudioDisabled) {
+  ASSERT_TRUE(InitDemuxer(true, true));
+  scoped_ptr<Cluster> cluster(kDefaultFirstCluster());
+  AppendData(cluster->data(), cluster->size());
+
+  DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::AUDIO);
+  ASSERT_TRUE(stream);
+
+  // The stream should no longer be present.
+  demuxer_->OnAudioRendererDisabled();
+  ASSERT_FALSE(demuxer_->GetStream(DemuxerStream::AUDIO));
+
+  // Normally this would return an audio buffer at timestamp zero, but
+  // all reads should return EOS buffers when disabled.
+  bool audio_read_done = false;
+  stream->Read(base::Bind(&OnReadDone_EOSExpected, &audio_read_done));
+  message_loop_.RunUntilIdle();
+
+  EXPECT_TRUE(audio_read_done);
+}
+
 }  // namespace media