Refactor MediaResource to be multi-stream capable

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 "media/filters/chunk_demuxer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
@@ skipping 992 matching lines @@
                          kWebMFlagKeyframe);
     } else {
       cb.AddBlockGroup(track_number, timecode, block_duration,
                        kWebMFlagKeyframe, static_cast<bool>(kWebMFlagKeyframe),
                        &data[0], data.size());
     }
 
     return cb.Finish();
   }
 
+  DemuxerStream* GetStream(DemuxerStream::Type type) {
+    std::vector<DemuxerStream*> streams = demuxer_->GetStreams();
+    for (const auto& stream : streams) {
+      if (stream->type() == type)
+        return stream;
+    }
+    return nullptr;
+  }
+
   void Read(DemuxerStream::Type type, const DemuxerStream::ReadCB& read_cb) {
-    demuxer_->GetStream(type)->Read(read_cb);
+    GetStream(type)->Read(read_cb);
     base::RunLoop().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 65 matching lines @@
     CheckExpectedRangesForMediaSource(expected);
   }
 
   void CheckExpectedRanges(const std::string& id, const std::string& expected) {
     CheckExpectedRanges(demuxer_->GetBufferedRanges(id), expected);
   }
 
   void CheckExpectedRanges(DemuxerStream::Type type,
                            const std::string& expected) {
     ChunkDemuxerStream* stream =
-        static_cast<ChunkDemuxerStream*>(demuxer_->GetStream(type));
+        static_cast<ChunkDemuxerStream*>(GetStream(type));
     CheckExpectedRanges(stream->GetBufferedRanges(kDefaultDuration()),
                         expected);
   }
 
   void CheckExpectedRanges(const Ranges<base::TimeDelta>& r,
                            const std::string& expected) {
     std::stringstream ss;
     ss << "{ ";
     for (size_t i = 0; i < r.size(); ++i) {
       ss << "[" << r.start(i).InMilliseconds() << ","
@@ skipping 10 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) {
-    DemuxerStream* stream = demuxer_->GetStream(type);
+    DemuxerStream* stream = GetStream(type);
     scoped_refptr<DecoderBuffer> buffer;
 
     *last_timestamp = kNoTimestamp;
     do {
       stream->Read(base::Bind(&ChunkDemuxerTest::StoreStatusAndBuffer,
                               base::Unretained(this), status, &buffer));
       base::RunLoop().RunUntilIdle();
       if (*status == DemuxerStream::kOk && !buffer->end_of_stream())
         *last_timestamp = buffer->timestamp();
     } while (*status == DemuxerStream::kOk && !buffer->end_of_stream());
   }
 
   void ExpectEndOfStream(DemuxerStream::Type type) {
     EXPECT_CALL(*this, ReadDone(DemuxerStream::kOk, IsEndOfStream()));
-    demuxer_->GetStream(type)->Read(base::Bind(
-        &ChunkDemuxerTest::ReadDone, base::Unretained(this)));
+    GetStream(type)->Read(
+        base::Bind(&ChunkDemuxerTest::ReadDone, base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
   }
 
   void ExpectRead(DemuxerStream::Type type, int64_t timestamp_in_ms) {
     EXPECT_CALL(*this, ReadDone(DemuxerStream::kOk,
                                 HasTimestamp(timestamp_in_ms)));
-    demuxer_->GetStream(type)->Read(base::Bind(
-        &ChunkDemuxerTest::ReadDone, base::Unretained(this)));
+    GetStream(type)->Read(
+        base::Bind(&ChunkDemuxerTest::ReadDone, base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
   }
 
   void ExpectConfigChanged(DemuxerStream::Type type) {
     EXPECT_CALL(*this, ReadDone(DemuxerStream::kConfigChanged, _));
-    demuxer_->GetStream(type)->Read(base::Bind(
-        &ChunkDemuxerTest::ReadDone, base::Unretained(this)));
+    GetStream(type)->Read(
+        base::Bind(&ChunkDemuxerTest::ReadDone, base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
   }
 
   void CheckExpectedBuffers(DemuxerStream* stream,
                             const std::string& expected) {
     std::vector<std::string> timestamps = base::SplitString(
         expected, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     std::stringstream ss;
     for (size_t i = 0; i < timestamps.size(); ++i) {
       // Initialize status to kAborted since it's possible for Read() to return
@@ skipping 177 matching lines @@
       stream_flags |= HAS_VIDEO;
 
     if (has_audio || has_video) {
       ASSERT_TRUE(InitDemuxerWithEncryptionInfo(
           stream_flags, is_audio_encrypted, is_video_encrypted));
     } else {
       ASSERT_FALSE(InitDemuxerWithEncryptionInfo(
           stream_flags, is_audio_encrypted, is_video_encrypted));
     }
 
-    DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
+    DemuxerStream* audio_stream = 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_GT(config.extra_data().size(), 0u);
       EXPECT_EQ(kSampleFormatPlanarF32, config.sample_format());
       EXPECT_EQ(is_audio_encrypted,
                 audio_stream->audio_decoder_config().is_encrypted());
       EXPECT_TRUE(static_cast<ChunkDemuxerStream*>(audio_stream)
                       ->supports_partial_append_window_trimming());
     } else {
       EXPECT_FALSE(audio_stream);
     }
 
-    DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+    DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
     if (has_video) {
       EXPECT_TRUE(video_stream);
       EXPECT_EQ(is_video_encrypted,
                 video_stream->video_decoder_config().is_encrypted());
       EXPECT_FALSE(static_cast<ChunkDemuxerStream*>(video_stream)
                        ->supports_partial_append_window_trimming());
     } else {
       EXPECT_FALSE(video_stream);
     }
 
@@ skipping 29 matching lines @@
       stream_flags |= HAS_VIDEO;
 
     ASSERT_TRUE(InitDemuxerWithEncryptionInfo(
         stream_flags, is_audio_encrypted, is_video_encrypted));
     ASSERT_TRUE(text_stream);
     EXPECT_EQ(DemuxerStream::TEXT, text_stream->type());
     EXPECT_EQ(kTextSubtitles, text_config.kind());
     EXPECT_FALSE(static_cast<ChunkDemuxerStream*>(text_stream)
                      ->supports_partial_append_window_trimming());
 
-    DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
+    DemuxerStream* audio_stream = 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_GT(config.extra_data().size(), 0u);
       EXPECT_EQ(kSampleFormatPlanarF32, config.sample_format());
       EXPECT_EQ(is_audio_encrypted,
                 audio_stream->audio_decoder_config().is_encrypted());
       EXPECT_TRUE(static_cast<ChunkDemuxerStream*>(audio_stream)
                       ->supports_partial_append_window_trimming());
     } else {
       EXPECT_FALSE(audio_stream);
     }
 
-    DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+    DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
     if (has_video) {
       EXPECT_TRUE(video_stream);
       EXPECT_EQ(is_video_encrypted,
                 video_stream->video_decoder_config().is_encrypted());
       EXPECT_FALSE(static_cast<ChunkDemuxerStream*>(video_stream)
                        ->supports_partial_append_window_trimming());
     } else {
       EXPECT_FALSE(video_stream);
     }
 
     ShutdownDemuxer();
     demuxer_.reset();
   }
 }
 
 TEST_F(ChunkDemuxerTest, SingleTextTrackIdChange) {
   // Test with 1 video stream, 1 audio, and 1 text stream. Send a second init
   // segment in which the text track ID changes. Verify appended buffers before
   // and after the second init segment map to the same underlying track buffers.
   CreateNewDemuxer();
   DemuxerStream* text_stream = NULL;
   TextTrackConfig text_config;
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(DoAll(SaveArg<0>(&text_stream),
                       SaveArg<1>(&text_config)));
   ASSERT_TRUE(InitDemuxerWithEncryptionInfo(
       HAS_TEXT | HAS_AUDIO | HAS_VIDEO, false, false));
-  DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
-  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* audio_stream = GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(audio_stream);
   ASSERT_TRUE(video_stream);
   ASSERT_TRUE(text_stream);
 
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "0K 23K", 23),
                      MuxedStreamInfo(kVideoTrackNum, "0K 30", 30),
                      MuxedStreamInfo(kTextTrackNum, "10K"));
   CheckExpectedRanges("{ [0,46) }");
 
   std::unique_ptr<uint8_t[]> info_tracks;
@@ skipping 21 matching lines @@
   ShutdownDemuxer();
 }
 
 TEST_F(ChunkDemuxerTest, AudioVideoTrackIdsChange) {
   // Test with 1 audio and 1 video stream. Send a second init segment in which
   // the audio and video track IDs change. Verify that appended buffers before
   // and after the second init segment map to the same underlying track buffers.
   CreateNewDemuxer();
   ASSERT_TRUE(
       InitDemuxerWithEncryptionInfo(HAS_AUDIO | HAS_VIDEO, false, false));
-  DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
-  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* audio_stream = GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(audio_stream);
   ASSERT_TRUE(video_stream);
 
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "0K 23K", 23),
                      MuxedStreamInfo(kVideoTrackNum, "0K 30", 30));
   CheckExpectedRanges("{ [0,46) }");
 
   EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   ASSERT_TRUE(AppendInitSegment(HAS_AUDIO | HAS_VIDEO |
                                 USE_ALTERNATE_AUDIO_TRACK_ID |
@@ skipping 13 matching lines @@
   // algorithm correctly sets the needs random access point flag to true for all
   // track buffers. Note that the first initialization segment is insufficient
   // to fully test this since needs random access point flag initializes to
   // true.
   CreateNewDemuxer();
   DemuxerStream* text_stream = NULL;
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
   ASSERT_TRUE(InitDemuxerWithEncryptionInfo(
       HAS_TEXT | HAS_AUDIO | HAS_VIDEO, false, false));
-  DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
-  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* audio_stream = GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(audio_stream && video_stream && text_stream);
 
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum, "23K",
                       WebMClusterParser::kDefaultAudioBufferDurationInMs),
       MuxedStreamInfo(kVideoTrackNum, "0 30K", 30),
       MuxedStreamInfo(kTextTrackNum, "25K 40K"));
   CheckExpectedRanges("{ [23,46) }");
 
   EXPECT_CALL(*this, InitSegmentReceivedMock(_));
@@ skipping 45 matching lines @@
 }
 
 // Verifies that all streams waiting for data receive an end of stream
 // buffer when Shutdown() is called.
 TEST_F(ChunkDemuxerTest, Shutdown_EndOfStreamWhileWaitingForData) {
   DemuxerStream* text_stream = NULL;
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO | HAS_TEXT));
 
-  DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
-  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* audio_stream = GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
 
   bool audio_read_done = false;
   bool video_read_done = false;
   bool text_read_done = false;
   audio_stream->Read(base::Bind(&OnReadDone_EOSExpected, &audio_read_done));
   video_stream->Read(base::Bind(&OnReadDone_EOSExpected, &video_read_done));
   text_stream->Read(base::Bind(&OnReadDone_EOSExpected, &text_read_done));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(audio_read_done);
@@ skipping 99 matching lines @@
   ReadVideo(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(0),
                        &video_read_done));
 
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 }
 
 TEST_F(ChunkDemuxerTest, OutOfOrderClusters) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
-  DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
-  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* audio_stream = GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
 
   ASSERT_TRUE(AppendCluster(kDefaultFirstCluster()));
   CheckExpectedBuffers(audio_stream, "0K 23K");
   CheckExpectedBuffers(video_stream, "0K 33");
   // Note: splice trimming changes durations. These are verified in lower level
   // tests. See SourceBufferStreamTest.Audio_SpliceTrimmingForOverlap.
   EXPECT_MEDIA_LOG(TrimmedSpliceOverlap(10000, 0, 13000));
   ASSERT_TRUE(AppendCluster(GenerateCluster(10, 4)));
   Seek(base::TimeDelta());
   CheckExpectedBuffers(audio_stream, "0K 10K 33K");
@@ skipping 159 matching lines @@
 
   EXPECT_CALL(host_,
               OnDemuxerError(CHUNK_DEMUXER_ERROR_EOS_STATUS_NETWORK_ERROR));
   MarkEndOfStream(CHUNK_DEMUXER_ERROR_EOS_STATUS_NETWORK_ERROR);
 }
 
 // Helper class to reduce duplicate code when testing end of stream
 // Read() behavior.
 class EndOfStreamHelper {
  public:
-  explicit EndOfStreamHelper(Demuxer* demuxer)
-      : demuxer_(demuxer),
+  explicit EndOfStreamHelper(DemuxerStream* audio, DemuxerStream* video)
+      : audio_stream_(audio),
+        video_stream_(video),
         audio_read_done_(false),
-        video_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_);
 
-    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_));
+    audio_stream_->Read(base::Bind(&OnEndOfStreamReadDone, &audio_read_done_));
+    video_stream_->Read(base::Bind(&OnEndOfStreamReadDone, &video_read_done_));
     base::RunLoop().RunUntilIdle();
   }
 
   // Check to see if |audio_read_done_| and |video_read_done_| variables
   // match |expected|.
   void CheckIfReadDonesWereCalled(bool expected) {
     base::RunLoop().RunUntilIdle();
     EXPECT_EQ(expected, audio_read_done_);
     EXPECT_EQ(expected, video_read_done_);
   }
 
  private:
   static void OnEndOfStreamReadDone(
       bool* called,
       DemuxerStream::Status status,
       const scoped_refptr<DecoderBuffer>& buffer) {
     EXPECT_EQ(status, DemuxerStream::kOk);
     EXPECT_TRUE(buffer->end_of_stream());
     *called = true;
   }
 
-  Demuxer* demuxer_;
+  DemuxerStream* audio_stream_;
+  DemuxerStream* video_stream_;
   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 MarkEndOfStream() is called.
 TEST_F(ChunkDemuxerTest, EndOfStreamWithPendingReads) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   ASSERT_TRUE(AppendCluster(GenerateCluster(0, 2)));
 
   bool audio_read_done_1 = false;
   bool video_read_done_1 = false;
-  EndOfStreamHelper end_of_stream_helper_1(demuxer_.get());
-  EndOfStreamHelper end_of_stream_helper_2(demuxer_.get());
+  DemuxerStream* audio_stream = GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
+  EndOfStreamHelper end_of_stream_helper_1(audio_stream, video_stream);
+  EndOfStreamHelper end_of_stream_helper_2(audio_stream, video_stream);
 
   ReadAudio(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(0),
                        &audio_read_done_1));
   ReadVideo(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(0),
                        &video_read_done_1));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(audio_read_done_1);
@@ skipping 13 matching lines @@
 
 // Make sure that all Read() calls after we get an MarkEndOfStream()
 // call return an "end of stream" buffer.
 TEST_F(ChunkDemuxerTest, ReadsAfterEndOfStream) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   ASSERT_TRUE(AppendCluster(GenerateCluster(0, 2)));
 
   bool audio_read_done_1 = false;
   bool video_read_done_1 = false;
-  EndOfStreamHelper end_of_stream_helper_1(demuxer_.get());
-  EndOfStreamHelper end_of_stream_helper_2(demuxer_.get());
-  EndOfStreamHelper end_of_stream_helper_3(demuxer_.get());
+  DemuxerStream* audio_stream = GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
+  EndOfStreamHelper end_of_stream_helper_1(audio_stream, video_stream);
+  EndOfStreamHelper end_of_stream_helper_2(audio_stream, video_stream);
+  EndOfStreamHelper end_of_stream_helper_3(audio_stream, video_stream);
 
   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 152 matching lines @@
     {100, 9},
     {133, 12},
     {kSkip, kSkip},
   };
 
   ExpectInitMediaLogs(HAS_AUDIO | HAS_VIDEO);
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(2)).Times(7);
   ASSERT_TRUE(ParseWebMFile("bear-320x240-live.webm", buffer_timestamps,
                             kInfiniteDuration));
 
-  DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
   EXPECT_EQ(DemuxerStream::LIVENESS_LIVE, audio->liveness());
-  DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* video = GetStream(DemuxerStream::VIDEO);
   EXPECT_EQ(DemuxerStream::LIVENESS_LIVE, video->liveness());
   EXPECT_EQ(212949, demuxer_->GetMemoryUsage());
 }
 
 TEST_F(ChunkDemuxerTest, WebMFile_AudioOnly) {
   struct BufferTimestamps buffer_timestamps[] = {
     {kSkip, 0},
     {kSkip, 3},
     {kSkip, 6},
     {kSkip, 9},
@@ skipping 279 matching lines @@
       GenerateSingleStreamCluster(0, 92, kAudioTrackNum, kAudioBlockDuration)));
   ASSERT_TRUE(AppendCluster(video_id,
                             GenerateSingleStreamCluster(0, 132, kVideoTrackNum,
                                                         kVideoBlockDuration)));
 
   // Read() from audio should return normal buffers.
   GenerateAudioStreamExpectedReads(0, 4);
 
   // Audio stream will become inaccessible after |audio_id| is removed, so save
   // it here to read from it after RemoveId.
-  DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* audio_stream = GetStream(DemuxerStream::AUDIO);
 
   // Remove the audio id.
   demuxer_->RemoveId(audio_id);
 
   // Read() from audio should return "end of stream" buffers.
   bool audio_read_done = false;
   audio_stream->Read(base::Bind(&OnReadDone_EOSExpected, &audio_read_done));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(audio_read_done);
 
@@ skipping 667 matching lines @@
   ASSERT_TRUE(AppendCluster(kDefaultSecondCluster()));
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(kDefaultSecondClusterEndTimestamp)));
   MarkEndOfStream(PIPELINE_OK);
 
   demuxer_->Seek(seek_time, NewExpectedStatusCB(PIPELINE_OK));
 
   GenerateExpectedReads(0, 4);
   GenerateExpectedReads(46, 66, 5);
 
-  EndOfStreamHelper end_of_stream_helper(demuxer_.get());
+  DemuxerStream* audio_stream = GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
+  EndOfStreamHelper end_of_stream_helper(audio_stream, video_stream);
   end_of_stream_helper.RequestReads();
   end_of_stream_helper.CheckIfReadDonesWereCalled(true);
 }
 
 TEST_F(ChunkDemuxerTest, ConfigChange_Video) {
   InSequence s;
 
   ASSERT_TRUE(InitDemuxerWithConfigChangeData());
 
   DemuxerStream::Status status;
   base::TimeDelta last_timestamp;
 
-  DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* video = 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, ConfigChange_Audio) {
   InSequence s;
 
   ASSERT_TRUE(InitDemuxerWithConfigChangeData());
 
   DemuxerStream::Status status;
   base::TimeDelta last_timestamp;
 
-  DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* audio = 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);
 
   // Read until we encounter config 2.
@@ skipping 18 matching lines @@
   ReadUntilNotOkOrEndOfStream(DemuxerStream::AUDIO, &status, &last_timestamp);
   ASSERT_EQ(status, DemuxerStream::kOk);
   EXPECT_EQ(last_timestamp.InMilliseconds(), 2744);
 }
 
 TEST_F(ChunkDemuxerTest, ConfigChange_Seek) {
   InSequence s;
 
   ASSERT_TRUE(InitDemuxerWithConfigChangeData());
 
-  DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* video = 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 692 matching lines @@
   Seek(seek_time3);
   EXPECT_TRUE(demuxer_->EvictCodedFrames(kSourceId, seek_time3, 0));
   // Strictly speaking the current playback time is 23*6==138ms, so we could
   // release data up to 138ms, but we only release as much data as necessary
   // to bring memory usage under the limit, so we release only up to 115ms.
   CheckExpectedRanges("{ [115,230) }");
 }
 
 TEST_F(ChunkDemuxerTest, AppendWindow_Video) {
   ASSERT_TRUE(InitDemuxer(HAS_VIDEO));
-  DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* stream = GetStream(DemuxerStream::VIDEO);
 
   // Set the append window to [50,280).
   append_window_start_for_next_append_ = base::TimeDelta::FromMilliseconds(50);
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(280);
 
   // Append a cluster that starts before and ends after the append window.
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(30));
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum,
                             "0K 30 60 90 120K 150 180 210 240K 270 300 330K");
 
   // Verify that GOPs that start outside the window are not included
   // in the buffer. Also verify that buffers that start inside the
   // window and extend beyond the end of the window are not included.
   CheckExpectedRanges("{ [120,270) }");
   CheckExpectedBuffers(stream, "120K 150 180 210 240K");
 
   // Extend the append window to [50,650).
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(650);
 
   // Append more data and verify that adding buffers start at the next
   // key frame.
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(30));
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum,
                             "360 390 420K 450 480 510 540K 570 600 630K");
   CheckExpectedRanges("{ [120,270) [420,630) }");
 }
 
 TEST_F(ChunkDemuxerTest, AppendWindow_Audio) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
-  DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* stream = GetStream(DemuxerStream::AUDIO);
 
   // Set the append window to [50,280).
   append_window_start_for_next_append_ = base::TimeDelta::FromMilliseconds(50);
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(280);
 
   // Append a cluster that starts before and ends after the append window.
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(30));
   AppendSingleStreamCluster(
       kSourceId, kAudioTrackNum,
       "0K 30K 60K 90K 120K 150K 180K 210K 240K 270K 300K 330K");
@@ skipping 52 matching lines @@
   // Read a WebM file into memory and send the data to the demuxer.  The chunk
   // size has been chosen carefully to ensure the preroll buffer used by the
   // partial append window trim must come from a previous Append() call.
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-320x240-audio-only.webm");
   ExpectInitMediaLogs(HAS_AUDIO);
   EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(2));
   ASSERT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 128));
 
-  DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* stream = GetStream(DemuxerStream::AUDIO);
   CheckExpectedBuffers(stream, "50KP 50K 62K 86K 109K 122K 125K 128K");
 }
 
 TEST_F(ChunkDemuxerTest, AppendWindow_AudioConfigUpdateRemovesPreroll) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_,
       CreateInitDoneCB(base::TimeDelta::FromMilliseconds(2744), PIPELINE_OK),
       true);
   ASSERT_EQ(ChunkDemuxer::kOk, AddId(kSourceId, HAS_AUDIO));
 
   // Set the append window such that the first file is completely before the
   // append window.
   // Expect duration adjustment since actual duration differs slightly from
   // duration in the init segment.
   const base::TimeDelta duration_1 = base::TimeDelta::FromMilliseconds(2746);
   append_window_start_for_next_append_ = duration_1;
 
   // Read a WebM file into memory and append the data.
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-320x240-audio-only.webm");
   ExpectInitMediaLogs(HAS_AUDIO);
   EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(2));
   ASSERT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
   CheckExpectedRanges("{ }");
 
-  DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* stream = GetStream(DemuxerStream::AUDIO);
   AudioDecoderConfig config_1 = stream->audio_decoder_config();
 
   // Read a second WebM with a different config in and append the data.
   scoped_refptr<DecoderBuffer> buffer2 =
       ReadTestDataFile("bear-320x240-audio-only-48khz.webm");
   EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(21));
   EXPECT_CALL(host_, SetDuration(_)).Times(AnyNumber());
   ASSERT_TRUE(SetTimestampOffset(kSourceId, duration_1));
   ASSERT_TRUE(AppendDataInPieces(buffer2->data(), buffer2->data_size(), 512));
   CheckExpectedRanges("{ [2746,5519) }");
 
   Seek(duration_1);
   ExpectConfigChanged(DemuxerStream::AUDIO);
   ASSERT_FALSE(config_1.Matches(stream->audio_decoder_config()));
   CheckExpectedBuffers(stream, "2746K 2767K 2789K 2810K");
 }
 
 TEST_F(ChunkDemuxerTest, AppendWindow_Text) {
   DemuxerStream* text_stream = NULL;
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
   ASSERT_TRUE(InitDemuxer(HAS_VIDEO | HAS_TEXT));
-  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
 
   // Set the append window to [20,280).
   append_window_start_for_next_append_ = base::TimeDelta::FromMilliseconds(20);
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(280);
 
   // Append a cluster that starts before and ends after the append
   // window.
   AppendMuxedCluster(
       MuxedStreamInfo(kVideoTrackNum,
                       "0K 30 60 90 120K 150 180 210 240K 270 300 330K", 30),
@@ skipping 30 matching lines @@
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(50);
   demuxer_->StartWaitingForSeek(seek_time);
 }
 
 TEST_F(ChunkDemuxerTest, Remove_AudioVideoText) {
   DemuxerStream* text_stream = NULL;
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO | HAS_TEXT));
 
-  DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
-  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* audio_stream = GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
 
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum, "0K 20K 40K 60K 80K 100K 120K 140K", 20),
       MuxedStreamInfo(kVideoTrackNum, "0K 30 60 90 120K 150 180", 30),
       MuxedStreamInfo(kTextTrackNum, "0K 100K 200K"));
 
   CheckExpectedBuffers(audio_stream, "0K 20K 40K 60K 80K 100K 120K 140K");
   CheckExpectedBuffers(video_stream, "0K 30 60 90 120K 150 180");
   CheckExpectedBuffers(text_stream, "0K 100K 200K");
 
@@ skipping 12 matching lines @@
       MuxedStreamInfo(kTextTrackNum, "1K 101K 201K"));
 
   Seek(base::TimeDelta());
   CheckExpectedBuffers(audio_stream, "1K 21K 41K 61K 81K 101K 121K 141K");
   CheckExpectedBuffers(video_stream, "1K 31 61 91 121K 151 181");
   CheckExpectedBuffers(text_stream, "1K 101K 201K");
 }
 
 TEST_F(ChunkDemuxerTest, Remove_StartAtDuration) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
-  DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* audio_stream = GetStream(DemuxerStream::AUDIO);
 
   // Set the duration to something small so that the append that
   // follows updates the duration to reflect the end of the appended data.
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(1)));
   demuxer_->SetDuration(0.001);
 
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(160)));
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum,
@@ skipping 13 matching lines @@
 
 // Verifies that a Seek() will complete without text cues for
 // the seek point and will return cues after the seek position
 // when they are eventually appended.
 TEST_F(ChunkDemuxerTest, SeekCompletesWithoutTextCues) {
   DemuxerStream* text_stream = NULL;
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO | HAS_TEXT));
 
-  DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
-  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* audio_stream = GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
 
   base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(120);
   bool seek_cb_was_called = false;
   demuxer_->StartWaitingForSeek(seek_time);
   demuxer_->Seek(seek_time,
                  base::Bind(OnSeekDone_OKExpected, &seek_cb_was_called));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(seek_cb_was_called);
 
@@ skipping 67 matching lines @@
   ASSERT_TRUE(AppendCluster(GenerateCluster(0, 0, 4)));
   ASSERT_TRUE(AppendData(kCuesHeader, sizeof(kCuesHeader)));
   ASSERT_TRUE(AppendCluster(GenerateCluster(46, 66, 5)));
   CheckExpectedRanges("{ [0,115) }");
 }
 
 TEST_F(ChunkDemuxerTest, EvictCodedFramesTest) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   demuxer_->SetMemoryLimitsForTest(DemuxerStream::AUDIO, 10 * kBlockSize);
   demuxer_->SetMemoryLimitsForTest(DemuxerStream::VIDEO, 15 * kBlockSize);
-  DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
-  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* audio_stream = GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
 
   const char* kAudioStreamInfo = "0K 40K 80K 120K 160K 200K 240K 280K";
   const char* kVideoStreamInfo = "0K 10 20K 30 40K 50 60K 70 80K 90 100K "
       "110 120K 130 140K";
   // Append 8 blocks (80 bytes) of data to audio stream and 15 blocks (150
   // bytes) to video stream.
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, kAudioStreamInfo, 40),
                      MuxedStreamInfo(kVideoTrackNum, kVideoStreamInfo, 10));
   CheckExpectedBuffers(audio_stream, kAudioStreamInfo);
   CheckExpectedBuffers(video_stream, kVideoStreamInfo);
@@ skipping 59 matching lines @@
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   EXPECT_MEDIA_LOG(SegmentMissingFrames("1"));
   EXPECT_MEDIA_LOG(SegmentMissingFrames("2"));
   ASSERT_TRUE(AppendCluster(GenerateEmptyCluster(0)));
 }
 
 TEST_F(ChunkDemuxerTest, RelaxedKeyframe_FirstSegmentMissingKeyframe) {
   // Append V:[n n n][n n K]
   // Expect V:           [K]
   ASSERT_TRUE(InitDemuxer(HAS_VIDEO));
-  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
 
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(10)).Times(2);
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "0 10 20");
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "30 40 50K");
   CheckExpectedRanges("{ [50,60) }");
   CheckExpectedBuffers(video_stream, "50K");
 }
 
 TEST_F(ChunkDemuxerTest, RelaxedKeyframe_SecondSegmentMissingKeyframe) {
   // Append V:[K n n][n n n]
   // Expect V:[K n n][n n n]
   ASSERT_TRUE(InitDemuxer(HAS_VIDEO));
-  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
 
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(10)).Times(2);
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "0K 10 20");
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "30 40 50");
   CheckExpectedRanges("{ [0,60) }");
   CheckExpectedBuffers(video_stream, "0K 10 20 30 40 50");
 }
 
 TEST_F(ChunkDemuxerTest, RelaxedKeyframe_RemoveInterruptsCodedFrameGroup_1) {
   // Append V:[K n n]
   // Remove    *****
   // Append V:       [n n n][n K n]
   // Expect:                  [K n]
   ASSERT_TRUE(InitDemuxer(HAS_VIDEO));
-  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
 
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(10)).Times(3);
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "0K 10 20");
   demuxer_->Remove(kSourceId, base::TimeDelta(),
                    base::TimeDelta::FromMilliseconds(30));
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "30 40 50");
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "60 70K 80");
   CheckExpectedRanges("{ [70,90) }");
   CheckExpectedBuffers(video_stream, "70K 80");
 }
 
 TEST_F(ChunkDemuxerTest, RelaxedKeyframe_RemoveInterruptsCodedFrameGroup_2) {
   // Append V:[K n n][n n n][n K n]
   // Remove    *
   // Expect:                  [K n]
   ASSERT_TRUE(InitDemuxer(HAS_VIDEO));
-  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
 
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(10)).Times(3);
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "0K 10 20");
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "30 40 50");
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "60 70K 80");
   demuxer_->Remove(kSourceId, base::TimeDelta(),
                    base::TimeDelta::FromMilliseconds(10));
   CheckExpectedRanges("{ [70,90) }");
   CheckExpectedBuffers(video_stream, "70K 80");
 }
 
 TEST_F(ChunkDemuxerTest, RelaxedKeyframe_RemoveInterruptsCodedFrameGroup_3) {
   // Append V:[K n n][n n n][n K n]
   // Remove               *
   // Expect:  [K n n..n n]    [K n]
   ASSERT_TRUE(InitDemuxer(HAS_VIDEO));
-  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
 
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(10)).Times(3);
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "0K 10 20");
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "30 40 50");
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum, "60 70K 80");
   demuxer_->Remove(kSourceId, base::TimeDelta::FromMilliseconds(50),
                    base::TimeDelta::FromMilliseconds(60));
   CheckExpectedRanges("{ [0,50) [70,90) }");
   CheckExpectedBuffers(video_stream, "0K 10 20 30 40");
   Seek(base::TimeDelta::FromMilliseconds(70));
   CheckExpectedBuffers(video_stream, "70K 80");
 }
 
 TEST_F(ChunkDemuxerTest,
        RelaxedKeyframe_RemoveInterruptsMuxedCodedFrameGroup_1) {
   // Append muxed:
   //        A:[K K K]
   //        V:[K n n]
   // Remove    *****
   // Append muxed:
   //        A:       [K K K][K K K]
   //        V:       [n n n][n K n]
   // Expect:
   //        A:       [K K K][K K K]
   //        V                 [K n]
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
-  DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
-  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* audio_stream = GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
 
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "0K 10K 20D10K"),
                      MuxedStreamInfo(kVideoTrackNum, "0K 10 20", 10));
   demuxer_->Remove(kSourceId, base::TimeDelta(),
                    base::TimeDelta::FromMilliseconds(30));
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "30K 40K 50D10K"),
                      MuxedStreamInfo(kVideoTrackNum, "30 40 50", 10));
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "60K 70K 80D10K"),
                      MuxedStreamInfo(kVideoTrackNum, "60 70K 80", 10));
   CheckExpectedRanges(DemuxerStream::AUDIO, "{ [30,90) }");
@@ skipping 12 matching lines @@
   // Remove    *****
   // Append muxed:
   //        A:       [K K K][K K K]
   //        V:       [n n n][n K n]
   // Expect:
   //        A:       [K K K][K K K]
   //        V [................K n] (As would occur if there really were a
   //        jagged cluster start and not badly muxed clusters as used to
   //        simulate a jagged start in this test.)
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
-  DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
-  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* audio_stream = GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
 
   EXPECT_MEDIA_LOG(SegmentMissingFrames("1"));
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "0K 10K 20D10K"),
                      MuxedStreamInfo(kVideoTrackNum, ""));
   demuxer_->Remove(kSourceId, base::TimeDelta(),
                    base::TimeDelta::FromMilliseconds(30));
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "30K 40K 50D10K"),
                      MuxedStreamInfo(kVideoTrackNum, "30 40 50", 10));
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "60K 70K 80D10K"),
                      MuxedStreamInfo(kVideoTrackNum, "60 70K 80", 10));
@@ skipping 10 matching lines @@
   //        A:[K K K
   //        V:(Nothing yet. This is a jagged start, not simulated.)
   // Remove    *****
   // Append muxed:
   //        A:       K K K K K K]
   //        V:       n n n n K n]
   // Expect:
   //        A:      [K K K K K K]
   //        V [..............K n]
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
-  DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
-  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* audio_stream = GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
 
   std::vector<MuxedStreamInfo> msi(2);
   msi[0] =
       MuxedStreamInfo(kAudioTrackNum, "0K 10K 20K 30K 40K 50K 60K 70K 80D10K");
   msi[1] = MuxedStreamInfo(kVideoTrackNum, "31 41 51 61 71K 81", 10);
   std::unique_ptr<Cluster> cluster = GenerateMuxedCluster(msi);
 
   // Append the first part of the cluster, up to the beginning of the first
   // video simpleblock. The result should be just 4 audio blocks and no video
   // blocks are appended. Since the stream parser does not yet have a duration
@@ skipping 35 matching lines @@
 }
 
 void OnStreamStatusChanged(base::WaitableEvent* event,
                            DemuxerStream* stream,
                            bool enabled,
                            base::TimeDelta) {
   EXPECT_EQ(enabled, stream->enabled());
   event->Signal();
 }
 
-void CheckStreamStatusNotifications(DemuxerStream* stream) {
+void CheckStreamStatusNotifications(MediaResource* media_resource,
+                                    DemuxerStream* stream) {
   base::WaitableEvent event(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                             base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   ASSERT_TRUE(stream->enabled());
-  stream->SetStreamStatusChangeCB(base::Bind(&OnStreamStatusChanged,
-                                             base::Unretained(&event),
-                                             base::Unretained(stream)));
+  media_resource->SetStreamStatusChangeCB(
+      base::Bind(&OnStreamStatusChanged, base::Unretained(&event)));
 
   stream->set_enabled(false, base::TimeDelta());
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(event.IsSignaled());
 
   event.Reset();
   stream->set_enabled(true, base::TimeDelta());
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(event.IsSignaled());
 }
 
 TEST_F(ChunkDemuxerTest, StreamStatusNotifications) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
-  DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* audio_stream = GetStream(DemuxerStream::AUDIO);
   EXPECT_NE(nullptr, audio_stream);
-  CheckStreamStatusNotifications(audio_stream);
-  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  CheckStreamStatusNotifications(demuxer_.get(), audio_stream);
+  DemuxerStream* video_stream = GetStream(DemuxerStream::VIDEO);
   EXPECT_NE(nullptr, video_stream);
-  CheckStreamStatusNotifications(video_stream);
+  CheckStreamStatusNotifications(demuxer_.get(), video_stream);
 }
 
 TEST_F(ChunkDemuxerTest, MultipleIds) {
   CreateNewDemuxer();
   EXPECT_CALL(*this, DemuxerOpened());
   EXPECT_CALL(host_, SetDuration(_)).Times(2);
   demuxer_->Initialize(&host_, CreateInitDoneCB(kNoTimestamp, PIPELINE_OK),
                        true);
 
   const char* kId1 = "id1";
@@ skipping 49 matching lines @@
   EXPECT_EQ(AddId(kId1, "video/webm", "vorbis,vp8"), ChunkDemuxer::kOk);
 
   EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   EXPECT_MEDIA_LOG(FoundStream("video"));
   EXPECT_MEDIA_LOG(CodecName("video", "vp8"));
   EXPECT_MEDIA_LOG(FoundStream("audio"));
   EXPECT_MEDIA_LOG(CodecName("audio", "vorbis"));
 
   // Append init segment to ensure demuxer streams get created.
   ASSERT_TRUE(AppendInitSegmentWithSourceId(kId1, HAS_AUDIO | HAS_VIDEO));
-  EXPECT_NE(nullptr, demuxer_->GetStream(DemuxerStream::AUDIO));
-  EXPECT_NE(nullptr, demuxer_->GetStream(DemuxerStream::VIDEO));
+  EXPECT_NE(nullptr, GetStream(DemuxerStream::AUDIO));
+  EXPECT_NE(nullptr, GetStream(DemuxerStream::VIDEO));
 
   // Removing the id should remove also the DemuxerStreams.
   demuxer_->RemoveId(kId1);
-  EXPECT_EQ(nullptr, demuxer_->GetStream(DemuxerStream::AUDIO));
-  EXPECT_EQ(nullptr, demuxer_->GetStream(DemuxerStream::VIDEO));
+  EXPECT_EQ(nullptr, GetStream(DemuxerStream::AUDIO));
+  EXPECT_EQ(nullptr, GetStream(DemuxerStream::VIDEO));
 }
 
 // TODO(servolk): Add a unit test with multiple audio/video tracks using the
 // same codec type in a single SourceBufferState, when WebM parser supports
 // multiple tracks. crbug.com/646900
 
 class ChunkDemuxerMp4Vp9Test : public ChunkDemuxerTest,
                                public WithParamInterface<bool> {
  public:
   void SetUp() override {
@@ skipping 22 matching lines @@
   EXPECT_EQ(
       demuxer_->AddId("source_id", "video/mp4", "vp09.00.01.08.02.01.01.00"),
       expected);
 }
 
 INSTANTIATE_TEST_CASE_P(EnableDisableMp4Vp9Demuxing,
                         ChunkDemuxerMp4Vp9Test,
                         ::testing::Bool());
 
 }  // namespace media