MediaResource refactoring to support multiple streams

media/filters/ffmpeg_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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <deque>
 #include <string>
@@ skipping 87 matching lines @@
         &FFmpegDemuxerTest::OnEncryptedMediaInitData, base::Unretained(this));
 
     Demuxer::MediaTracksUpdatedCB tracks_updated_cb = base::Bind(
         &FFmpegDemuxerTest::OnMediaTracksUpdated, base::Unretained(this));
 
     demuxer_.reset(new FFmpegDemuxer(
         message_loop_.task_runner(), data_source_.get(),
         encrypted_media_init_data_cb, tracks_updated_cb, new MediaLog()));
   }
 
+  DemuxerStream* GetStream(DemuxerStream::Type type) {
+    std::vector<DemuxerStream*> streams = demuxer_->GetStreams();
+    for (const auto& s : streams) {
+      if (s->type() == type)
+        return s;
+    }
+    return nullptr;
+  }
+
   MOCK_METHOD1(CheckPoint, void(int v));
 
   void InitializeDemuxerInternal(bool enable_text,
                                  media::PipelineStatus expected_pipeline_status,
                                  base::Time timeline_offset) {
     if (expected_pipeline_status == PIPELINE_OK)
       EXPECT_CALL(host_, SetDuration(_));
     WaitableMessageLoopEvent event;
     demuxer_->Initialize(&host_, event.GetPipelineStatusCB(), enable_text);
     demuxer_->timeline_offset_ = timeline_offset;
@@ skipping 102 matching lines @@
   void OnMediaTracksUpdated(std::unique_ptr<MediaTracks> tracks) {
     CHECK(tracks.get());
     media_tracks_ = std::move(tracks);
   }
 
   // Accessor to demuxer internals.
   void set_duration_known(bool duration_known) {
     demuxer_->duration_known_ = duration_known;
   }
 
-  bool IsStreamStopped(DemuxerStream::Type type) {
-    DemuxerStream* stream = demuxer_->GetStream(type);
-    CHECK(stream);
-    return !static_cast<FFmpegDemuxerStream*>(stream)->demuxer_;
-  }
-
   // Fixture members.
   std::unique_ptr<FileDataSource> data_source_;
   std::unique_ptr<FFmpegDemuxer> demuxer_;
   StrictMock<MockDemuxerHost> host_;
   std::unique_ptr<MediaTracks> media_tracks_;
   base::MessageLoop message_loop_;
 
   AVFormatContext* format_context() {
     return demuxer_->glue_->format_context();
   }
@@ skipping 63 matching lines @@
   CreateDemuxer("no_audio_video.webm");
   WaitableMessageLoopEvent event;
   demuxer_->Initialize(&host_, event.GetPipelineStatusCB(), true);
   event.RunAndWaitForStatus(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_Successful) {
   CreateDemuxer("bear-320x240.webm");
   InitializeDemuxer();
 
+  std::vector<DemuxerStream*> streams = demuxer_->GetStreams();
+  EXPECT_EQ(2u, streams.size());
+
   // Video stream should be present.
-  DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* stream = streams[0];
   ASSERT_TRUE(stream);
   EXPECT_EQ(DemuxerStream::VIDEO, stream->type());
 
   const VideoDecoderConfig& video_config = stream->video_decoder_config();
   EXPECT_EQ(kCodecVP8, video_config.codec());
   EXPECT_EQ(PIXEL_FORMAT_YV12, video_config.format());
   EXPECT_EQ(320, video_config.coded_size().width());
   EXPECT_EQ(240, video_config.coded_size().height());
   EXPECT_EQ(0, video_config.visible_rect().x());
   EXPECT_EQ(0, video_config.visible_rect().y());
   EXPECT_EQ(320, video_config.visible_rect().width());
   EXPECT_EQ(240, video_config.visible_rect().height());
   EXPECT_EQ(320, video_config.natural_size().width());
   EXPECT_EQ(240, video_config.natural_size().height());
   EXPECT_TRUE(video_config.extra_data().empty());
 
   // Audio stream should be present.
-  stream = demuxer_->GetStream(DemuxerStream::AUDIO);
+  stream = streams[1];
   ASSERT_TRUE(stream);
   EXPECT_EQ(DemuxerStream::AUDIO, stream->type());
 
   const AudioDecoderConfig& audio_config = stream->audio_decoder_config();
   EXPECT_EQ(kCodecVorbis, audio_config.codec());
   EXPECT_EQ(32, audio_config.bits_per_channel());
   EXPECT_EQ(CHANNEL_LAYOUT_STEREO, audio_config.channel_layout());
   EXPECT_EQ(44100, audio_config.samples_per_second());
   EXPECT_EQ(kSampleFormatPlanarF32, audio_config.sample_format());
   EXPECT_FALSE(audio_config.extra_data().empty());
-
-  // Unknown stream should never be present.
-  EXPECT_FALSE(demuxer_->GetStream(DemuxerStream::UNKNOWN));
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_Multitrack) {
   // Open a file containing the following streams:
   //   Stream #0: Video (VP8)
   //   Stream #1: Audio (Vorbis)
   //   Stream #2: Subtitles (SRT)
   //   Stream #3: Video (Theora)
   //   Stream #4: Audio (16-bit signed little endian PCM)
   //
   // We should only pick the first audio/video streams we come across.
   CreateDemuxer("bear-320x240-multitrack.webm");
   InitializeDemuxer();
 
+  std::vector<DemuxerStream*> streams = demuxer_->GetStreams();
+  EXPECT_EQ(4u, streams.size());
+
   // Video stream should be VP8.
-  DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* stream = streams[0];
   ASSERT_TRUE(stream);
   EXPECT_EQ(DemuxerStream::VIDEO, stream->type());
   EXPECT_EQ(kCodecVP8, stream->video_decoder_config().codec());
 
   // Audio stream should be Vorbis.
-  stream = demuxer_->GetStream(DemuxerStream::AUDIO);
+  stream = streams[1];
   ASSERT_TRUE(stream);
   EXPECT_EQ(DemuxerStream::AUDIO, stream->type());
   EXPECT_EQ(kCodecVorbis, stream->audio_decoder_config().codec());
-
-  // Unknown stream should never be present.
-  EXPECT_FALSE(demuxer_->GetStream(DemuxerStream::UNKNOWN));
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_MultitrackText) {
   // Open a file containing the following streams:
   //   Stream #0: Video (VP8)
   //   Stream #1: Audio (Vorbis)
   //   Stream #2: Text (WebVTT)
 
   CreateDemuxer("bear-vp8-webvtt.webm");
   DemuxerStream* text_stream = NULL;
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
   InitializeDemuxerWithText();
   ASSERT_TRUE(text_stream);
   EXPECT_EQ(DemuxerStream::TEXT, text_stream->type());
 
+  std::vector<DemuxerStream*> streams = demuxer_->GetStreams();
   // Video stream should be VP8.
-  DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* stream = streams[0];
   ASSERT_TRUE(stream);
   EXPECT_EQ(DemuxerStream::VIDEO, stream->type());
   EXPECT_EQ(kCodecVP8, stream->video_decoder_config().codec());
 
   // Audio stream should be Vorbis.
-  stream = demuxer_->GetStream(DemuxerStream::AUDIO);
+  stream = streams[1];
   ASSERT_TRUE(stream);
   EXPECT_EQ(DemuxerStream::AUDIO, stream->type());
   EXPECT_EQ(kCodecVorbis, stream->audio_decoder_config().codec());
-
-  // Unknown stream should never be present.
-  EXPECT_FALSE(demuxer_->GetStream(DemuxerStream::UNKNOWN));
 }
 
 TEST_F(FFmpegDemuxerTest, Initialize_Encrypted) {
   EXPECT_CALL(*this,
               OnEncryptedMediaInitData(
                   EmeInitDataType::WEBM,
                   std::vector<uint8_t>(kEncryptedMediaInitData,
                                        kEncryptedMediaInitData +
                                            arraysize(kEncryptedMediaInitData))))
       .Times(Exactly(2));
 
   CreateDemuxer("bear-320x240-av_enc-av.webm");
   InitializeDemuxer();
 }
 
 TEST_F(FFmpegDemuxerTest, AbortPendingReads) {
   // We test that on a successful audio packet read.
   CreateDemuxer("bear-320x240.webm");
   InitializeDemuxer();
 
   // Attempt a read from the audio stream and run the message loop until done.
-  DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
+  std::vector<DemuxerStream*> streams = demuxer_->GetStreams();
+  DemuxerStream* audio = streams[1];
 
   // Depending on where in the reading process ffmpeg is, an error may cause the
   // stream to be marked as EOF.  Simulate this here to ensure it is properly
   // cleared by the AbortPendingReads() call.
   format_context()->pb->eof_reached = 1;
   audio->Read(NewReadCB(FROM_HERE, 29, 0, true, DemuxerStream::kAborted));
   demuxer_->AbortPendingReads();
   base::RunLoop().Run();
 
   // Additional reads should also be aborted (until a Seek()).
   audio->Read(NewReadCB(FROM_HERE, 29, 0, true, DemuxerStream::kAborted));
   base::RunLoop().Run();
 
   // Ensure blocking thread has completed outstanding work.
   demuxer_->Stop();
   EXPECT_EQ(format_context()->pb->eof_reached, 0);
 
   // Calling abort after stop should not crash.
   demuxer_->AbortPendingReads();
   demuxer_.reset();
 }
 
 TEST_F(FFmpegDemuxerTest, Read_Audio) {
   // We test that on a successful audio packet read.
   CreateDemuxer("bear-320x240.webm");
   InitializeDemuxer();
 
   // Attempt a read from the audio stream and run the message loop until done.
-  DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
+  std::vector<DemuxerStream*> streams = demuxer_->GetStreams();
+  DemuxerStream* audio = streams[1];
 
   audio->Read(NewReadCB(FROM_HERE, 29, 0, true));
   base::RunLoop().Run();
 
   audio->Read(NewReadCB(FROM_HERE, 27, 3000, true));
   base::RunLoop().Run();
 
   EXPECT_EQ(22084, demuxer_->GetMemoryUsage());
 }
 
 TEST_F(FFmpegDemuxerTest, Read_Video) {
   // We test that on a successful video packet read.
   CreateDemuxer("bear-320x240.webm");
   InitializeDemuxer();
 
   // Attempt a read from the video stream and run the message loop until done.
-  DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
+  std::vector<DemuxerStream*> streams = demuxer_->GetStreams();
+  DemuxerStream* video = streams[0];
 
   video->Read(NewReadCB(FROM_HERE, 22084, 0, true));
   base::RunLoop().Run();
 
   video->Read(NewReadCB(FROM_HERE, 1057, 33000, false));
   base::RunLoop().Run();
 
   EXPECT_EQ(323, demuxer_->GetMemoryUsage());
 }
 
@@ skipping 12 matching lines @@
 
   text_stream->Read(NewReadCB(FROM_HERE, 19, 500000, true));
   base::RunLoop().Run();
 }
 
 TEST_F(FFmpegDemuxerTest, SeekInitialized_NoVideoStartTime) {
   CreateDemuxer("audio-start-time-only.webm");
   InitializeDemuxer();
   // Video stream should be preferred for seeking even if video start time is
   // unknown.
-  DemuxerStream* vstream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  std::vector<DemuxerStream*> streams = demuxer_->GetStreams();
+  DemuxerStream* vstream = streams[0];
   EXPECT_EQ(vstream, preferred_seeking_stream(base::TimeDelta()));
 }
 
 TEST_F(FFmpegDemuxerTest, Seeking_PreferredStreamSelection) {
   const int64_t kTimelineOffsetMs = 1352550896000LL;
 
   // Test the start time is the first timestamp of the video and audio stream.
   CreateDemuxer("nonzero-start-time.webm");
   InitializeDemuxerWithTimelineOffset(
       base::Time::FromJsTime(kTimelineOffsetMs));
 
-  DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
-  DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
+  std::vector<DemuxerStream*> streams = demuxer_->GetStreams();
+  DemuxerStream* video = streams[0];
+  DemuxerStream* audio = streams[1];
 
   const base::TimeDelta video_start_time =
       base::TimeDelta::FromMicroseconds(400000);
   const base::TimeDelta audio_start_time =
       base::TimeDelta::FromMicroseconds(396000);
 
   // Seeking to a position lower than the start time of either stream should
   // prefer video stream for seeking.
   EXPECT_EQ(video, preferred_seeking_stream(base::TimeDelta()));
   // Seeking to a position that has audio data, but not video, should prefer
@@ skipping 25 matching lines @@
 
 TEST_F(FFmpegDemuxerTest, Read_VideoPositiveStartTime) {
   const int64_t kTimelineOffsetMs = 1352550896000LL;
 
   // Test the start time is the first timestamp of the video and audio stream.
   CreateDemuxer("nonzero-start-time.webm");
   InitializeDemuxerWithTimelineOffset(
       base::Time::FromJsTime(kTimelineOffsetMs));
 
   // Attempt a read from the video stream and run the message loop until done.
-  DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
-  DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
+  std::vector<DemuxerStream*> streams = demuxer_->GetStreams();
+  DemuxerStream* video = streams[0];
+  DemuxerStream* audio = streams[1];
 
   const base::TimeDelta video_start_time =
       base::TimeDelta::FromMicroseconds(400000);
   const base::TimeDelta audio_start_time =
       base::TimeDelta::FromMicroseconds(396000);
 
   // Run the test twice with a seek in between.
   for (int i = 0; i < 2; ++i) {
     video->Read(NewReadCB(FROM_HERE, 5636, video_start_time.InMicroseconds(),
                           true));
@@ skipping 17 matching lines @@
 }
 
 TEST_F(FFmpegDemuxerTest, Read_AudioNoStartTime) {
   // FFmpeg does not set timestamps when demuxing wave files.  Ensure that the
   // demuxer sets a start time of zero in this case.
   CreateDemuxer("sfx_s24le.wav");
   InitializeDemuxer();
 
   // Run the test twice with a seek in between.
   for (int i = 0; i < 2; ++i) {
-    demuxer_->GetStream(DemuxerStream::AUDIO)
-        ->Read(NewReadCB(FROM_HERE, 4095, 0, true));
+    GetStream(DemuxerStream::AUDIO)->Read(NewReadCB(FROM_HERE, 4095, 0, true));
     base::RunLoop().Run();
     EXPECT_EQ(base::TimeDelta(), demuxer_->start_time());
 
     // Seek back to the beginning and repeat the test.
     WaitableMessageLoopEvent event;
     demuxer_->Seek(base::TimeDelta(), event.GetPipelineStatusCB());
     event.RunAndWaitForStatus(PIPELINE_OK);
   }
 }
 
 // TODO(dalecurtis): Test is disabled since FFmpeg does not currently guarantee
 // the order of demuxed packets in OGG containers.  Re-enable and fix key frame
 // expectations once we decide to either workaround it or attempt a fix
 // upstream.  See http://crbug.com/387996.
 TEST_F(FFmpegDemuxerTest,
        DISABLED_Read_AudioNegativeStartTimeAndOggDiscard_Bear) {
   // Many ogg files have negative starting timestamps, so ensure demuxing and
   // seeking work correctly with a negative start time.
   CreateDemuxer("bear.ogv");
   InitializeDemuxer();
 
   // Attempt a read from the video stream and run the message loop until done.
-  DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
-  DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
+  std::vector<DemuxerStream*> streams = demuxer_->GetStreams();
+  DemuxerStream* video = streams[0];
+  DemuxerStream* audio = streams[1];
 
   // Run the test twice with a seek in between.
   for (int i = 0; i < 2; ++i) {
     audio->Read(
         NewReadCBWithCheckedDiscard(FROM_HERE, 40, 0, kInfiniteDuration, true));
     base::RunLoop().Run();
     audio->Read(NewReadCBWithCheckedDiscard(FROM_HERE, 41, 2903,
                                             kInfiniteDuration, true));
     base::RunLoop().Run();
     audio->Read(NewReadCBWithCheckedDiscard(
@@ skipping 24 matching lines @@
 // Same test above, but using sync2.ogv which has video stream muxed before the
 // audio stream, so seeking based only on start time will fail since ffmpeg is
 // essentially just seeking based on file position.
 TEST_F(FFmpegDemuxerTest, Read_AudioNegativeStartTimeAndOggDiscard_Sync) {
   // Many ogg files have negative starting timestamps, so ensure demuxing and
   // seeking work correctly with a negative start time.
   CreateDemuxer("sync2.ogv");
   InitializeDemuxer();
 
   // Attempt a read from the video stream and run the message loop until done.
-  DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
-  DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
+  std::vector<DemuxerStream*> streams = demuxer_->GetStreams();
+  DemuxerStream* video = streams[0];
+  DemuxerStream* audio = streams[1];
 
   // Run the test twice with a seek in between.
   for (int i = 0; i < 2; ++i) {
     audio->Read(NewReadCBWithCheckedDiscard(
         FROM_HERE, 1, 0, base::TimeDelta::FromMicroseconds(2902), true));
     base::RunLoop().Run();
 
     audio->Read(NewReadCB(FROM_HERE, 1, 2902, true));
     base::RunLoop().Run();
     EXPECT_EQ(base::TimeDelta::FromMicroseconds(-2902),
@@ skipping 19 matching lines @@
   }
 }
 
 // Similar to the test above, but using an opus clip with a large amount of
 // pre-skip, which ffmpeg encodes as negative timestamps.
 TEST_F(FFmpegDemuxerTest, Read_AudioNegativeStartTimeAndOpusDiscard_Sync) {
   CreateDemuxer("opus-trimming-video-test.webm");
   InitializeDemuxer();
 
   // Attempt a read from the video stream and run the message loop until done.
-  DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
-  DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
+  std::vector<DemuxerStream*> streams = demuxer_->GetStreams();
+  DemuxerStream* video = streams[0];
+  DemuxerStream* audio = streams[1];
   EXPECT_EQ(audio->audio_decoder_config().codec_delay(), 65535);
 
   // Packet size to timestamp (in microseconds) mapping for the first N packets
   // which should be fully discarded.
   static const int kTestExpectations[][2] = {
       {635, 0},      {594, 120000},  {597, 240000}, {591, 360000},
       {582, 480000}, {583, 600000},  {592, 720000}, {567, 840000},
       {579, 960000}, {572, 1080000}, {583, 1200000}};
 
   // Run the test twice with a seek in between.
@@ skipping 24 matching lines @@
   }
 }
 
 // Similar to the test above, but using sfx-opus.ogg, which has a much smaller
 // amount of discard padding and no |start_time| set on the AVStream.
 TEST_F(FFmpegDemuxerTest, Read_AudioNegativeStartTimeAndOpusSfxDiscard_Sync) {
   CreateDemuxer("sfx-opus.ogg");
   InitializeDemuxer();
 
   // Attempt a read from the video stream and run the message loop until done.
-  DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
+  std::vector<DemuxerStream*> streams = demuxer_->GetStreams();
+  DemuxerStream* audio = streams[0];
   EXPECT_EQ(audio->audio_decoder_config().codec_delay(), 312);
 
    // Run the test twice with a seek in between.
   for (int i = 0; i < 2; ++i) {
     audio->Read(NewReadCB(FROM_HERE, 314, 0, true));
     base::RunLoop().Run();
 
     audio->Read(NewReadCB(FROM_HERE, 244, 20000, true));
     base::RunLoop().Run();
 
     // Though the internal start time may be below zero, the exposed media time
     // must always be greater than zero.
     EXPECT_EQ(base::TimeDelta(), demuxer_->GetStartTime());
 
     // Seek back to the beginning and repeat the test.
     WaitableMessageLoopEvent event;
     demuxer_->Seek(base::TimeDelta(), event.GetPipelineStatusCB());
     event.RunAndWaitForStatus(PIPELINE_OK);
   }
 }
 
 TEST_F(FFmpegDemuxerTest, Read_EndOfStream) {
   // Verify that end of stream buffers are created.
   CreateDemuxer("bear-320x240.webm");
   InitializeDemuxer();
-  ReadUntilEndOfStream(demuxer_->GetStream(DemuxerStream::AUDIO));
+  std::vector<DemuxerStream*> streams = demuxer_->GetStreams();
+  DemuxerStream* audio = streams[0];
+  ReadUntilEndOfStream(audio);
 }
 
 TEST_F(FFmpegDemuxerTest, Read_EndOfStreamText) {
   // Verify that end of stream buffers are created.
   CreateDemuxer("bear-vp8-webvtt.webm");
   DemuxerStream* text_stream = NULL;
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
   InitializeDemuxerWithText();
   ASSERT_TRUE(text_stream);
   EXPECT_EQ(DemuxerStream::TEXT, text_stream->type());
 
   bool got_eos_buffer = false;
   const int kMaxBuffers = 10;
   for (int i = 0; !got_eos_buffer && i < kMaxBuffers; i++) {
     text_stream->Read(base::Bind(&EosOnReadDone, &got_eos_buffer));
     base::RunLoop().Run();
   }
 
   EXPECT_TRUE(got_eos_buffer);
 }
 
 TEST_F(FFmpegDemuxerTest, Read_EndOfStream_NoDuration) {
   // Verify that end of stream buffers are created.
   CreateDemuxer("bear-320x240.webm");
   InitializeDemuxer();
   set_duration_known(false);
   EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(2767)));
-  ReadUntilEndOfStream(demuxer_->GetStream(DemuxerStream::AUDIO));
-  ReadUntilEndOfStream(demuxer_->GetStream(DemuxerStream::VIDEO));
+  ReadUntilEndOfStream(GetStream(DemuxerStream::AUDIO));
+  ReadUntilEndOfStream(GetStream(DemuxerStream::VIDEO));
 }
 
 TEST_F(FFmpegDemuxerTest, Read_EndOfStream_NoDuration_VideoOnly) {
   // Verify that end of stream buffers are created.
   CreateDemuxer("bear-320x240-video-only.webm");
   InitializeDemuxer();
   set_duration_known(false);
   EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(2736)));
-  ReadUntilEndOfStream(demuxer_->GetStream(DemuxerStream::VIDEO));
+  ReadUntilEndOfStream(GetStream(DemuxerStream::VIDEO));
 }
 
 TEST_F(FFmpegDemuxerTest, Read_EndOfStream_NoDuration_AudioOnly) {
   // Verify that end of stream buffers are created.
   CreateDemuxer("bear-320x240-audio-only.webm");
   InitializeDemuxer();
   set_duration_known(false);
   EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(2767)));
-  ReadUntilEndOfStream(demuxer_->GetStream(DemuxerStream::AUDIO));
+  ReadUntilEndOfStream(GetStream(DemuxerStream::AUDIO));
 }
 
 TEST_F(FFmpegDemuxerTest, Read_EndOfStream_NoDuration_UnsupportedStream) {
   // Verify that end of stream buffers are created and we don't crash
   // if there are streams in the file that we don't support.
   CreateDemuxer("vorbis_audio_wmv_video.mkv");
   InitializeDemuxer();
   set_duration_known(false);
   EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(1014)));
-  ReadUntilEndOfStream(demuxer_->GetStream(DemuxerStream::AUDIO));
+  ReadUntilEndOfStream(GetStream(DemuxerStream::AUDIO));
 }
 
 TEST_F(FFmpegDemuxerTest, Seek) {
   // We're testing that the demuxer frees all queued packets when it receives
   // a Seek().
   CreateDemuxer("bear-320x240.webm");
   InitializeDemuxer();
 
   // Get our streams.
-  DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
-  DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* video = GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
   ASSERT_TRUE(video);
   ASSERT_TRUE(audio);
 
   // Read a video packet and release it.
   video->Read(NewReadCB(FROM_HERE, 22084, 0, true));
   base::RunLoop().Run();
 
   // Issue a simple forward seek, which should discard queued packets.
   WaitableMessageLoopEvent event;
   demuxer_->Seek(base::TimeDelta::FromMicroseconds(1000000),
@@ skipping 15 matching lines @@
   // Video read #2.
   video->Read(NewReadCB(FROM_HERE, 1906, 834000, false));
   base::RunLoop().Run();
 }
 
 TEST_F(FFmpegDemuxerTest, CancelledSeek) {
   CreateDemuxer("bear-320x240.webm");
   InitializeDemuxer();
 
   // Get our streams.
-  DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
-  DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* video = GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
   ASSERT_TRUE(video);
   ASSERT_TRUE(audio);
 
   // Read a video packet and release it.
   video->Read(NewReadCB(FROM_HERE, 22084, 0, true));
   base::RunLoop().Run();
 
   // Issue a simple forward seek, which should discard queued packets.
   WaitableMessageLoopEvent event;
   demuxer_->Seek(base::TimeDelta::FromMicroseconds(1000000),
                  event.GetPipelineStatusCB());
   // FFmpegDemuxer does not care what the previous seek time was when canceling.
   demuxer_->CancelPendingSeek(base::TimeDelta::FromSeconds(12345));
   event.RunAndWaitForStatus(PIPELINE_OK);
 }
 
 TEST_F(FFmpegDemuxerTest, SeekText) {
   // We're testing that the demuxer frees all queued packets when it receives
   // a Seek().
   CreateDemuxer("bear-vp8-webvtt.webm");
   DemuxerStream* text_stream = NULL;
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
   InitializeDemuxerWithText();
   ASSERT_TRUE(text_stream);
   EXPECT_EQ(DemuxerStream::TEXT, text_stream->type());
 
   // Get our streams.
-  DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
-  DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* video = GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
   ASSERT_TRUE(video);
   ASSERT_TRUE(audio);
 
   // Read a text packet and release it.
   text_stream->Read(NewReadCB(FROM_HERE, 31, 0, true));
   base::RunLoop().Run();
 
   // Issue a simple forward seek, which should discard queued packets.
   WaitableMessageLoopEvent event;
   demuxer_->Seek(base::TimeDelta::FromMicroseconds(1000000),
@@ skipping 25 matching lines @@
   base::RunLoop().Run();
 }
 
 TEST_F(FFmpegDemuxerTest, Stop) {
   // Tests that calling Read() on a stopped demuxer stream immediately deletes
   // the callback.
   CreateDemuxer("bear-320x240.webm");
   InitializeDemuxer();
 
   // Get our stream.
-  DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
   ASSERT_TRUE(audio);
 
   demuxer_->Stop();
 
   // Reads after being stopped are all EOS buffers.
   StrictMock<base::MockCallback<DemuxerStream::ReadCB>> callback;
   EXPECT_CALL(callback, Run(DemuxerStream::kOk, IsEndOfStreamBuffer()));
 
   // Attempt the read...
   audio->Read(callback.Get());
   base::RunLoop().RunUntilIdle();
 
   // Don't let the test call Stop() again.
   demuxer_.reset();
 }
 
 // Verify that seek works properly when the WebM cues data is at the start of
 // the file instead of at the end.
 TEST_F(FFmpegDemuxerTest, SeekWithCuesBeforeFirstCluster) {
   CreateDemuxer("bear-320x240-cues-in-front.webm");
   InitializeDemuxer();
 
   // Get our streams.
-  DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
-  DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* video = GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
   ASSERT_TRUE(video);
   ASSERT_TRUE(audio);
 
   // Read a video packet and release it.
   video->Read(NewReadCB(FROM_HERE, 22084, 0, true));
   base::RunLoop().Run();
 
   // Issue a simple forward seek, which should discard queued packets.
   WaitableMessageLoopEvent event;
   demuxer_->Seek(base::TimeDelta::FromMicroseconds(2500000),
@@ skipping 29 matching lines @@
 
 #if BUILDFLAG(USE_PROPRIETARY_CODECS)
 // Ensure MP3 files with large image/video based ID3 tags demux okay.  FFmpeg
 // will hand us a video stream to the data which will likely be in a format we
 // don't accept as video; e.g. PNG.
 TEST_F(FFmpegDemuxerTest, Mp3WithVideoStreamID3TagData) {
   CreateDemuxer("id3_png_test.mp3");
   InitializeDemuxer();
 
   // Ensure the expected streams are present.
-  EXPECT_FALSE(demuxer_->GetStream(DemuxerStream::VIDEO));
-  EXPECT_TRUE(demuxer_->GetStream(DemuxerStream::AUDIO));
+  EXPECT_FALSE(GetStream(DemuxerStream::VIDEO));
+  EXPECT_TRUE(GetStream(DemuxerStream::AUDIO));
 }
 #endif
 
 // Ensure a video with an unsupported audio track still results in the video
 // stream being demuxed.
 TEST_F(FFmpegDemuxerTest, UnsupportedAudioSupportedVideoDemux) {
   CreateDemuxer("speex_audio_vorbis_video.ogv");
   InitializeDemuxer();
 
   // Ensure the expected streams are present.
-  EXPECT_TRUE(demuxer_->GetStream(DemuxerStream::VIDEO));
-  EXPECT_FALSE(demuxer_->GetStream(DemuxerStream::AUDIO));
+  EXPECT_TRUE(GetStream(DemuxerStream::VIDEO));
+  EXPECT_FALSE(GetStream(DemuxerStream::AUDIO));
 }
 
 // Ensure a video with an unsupported video track still results in the audio
 // stream being demuxed.
 TEST_F(FFmpegDemuxerTest, UnsupportedVideoSupportedAudioDemux) {
   CreateDemuxer("vorbis_audio_wmv_video.mkv");
   InitializeDemuxer();
 
   // Ensure the expected streams are present.
-  EXPECT_FALSE(demuxer_->GetStream(DemuxerStream::VIDEO));
-  EXPECT_TRUE(demuxer_->GetStream(DemuxerStream::AUDIO));
+  EXPECT_FALSE(GetStream(DemuxerStream::VIDEO));
+  EXPECT_TRUE(GetStream(DemuxerStream::AUDIO));
 }
 
 #if BUILDFLAG(USE_PROPRIETARY_CODECS)
 // FFmpeg returns null data pointers when samples have zero size, leading to
 // mistakenly creating end of stream buffers http://crbug.com/169133
 TEST_F(FFmpegDemuxerTest, MP4_ZeroStszEntry) {
   CreateDemuxer("bear-1280x720-zero-stsz-entry.mp4");
   InitializeDemuxer();
-  ReadUntilEndOfStream(demuxer_->GetStream(DemuxerStream::AUDIO));
+  ReadUntilEndOfStream(GetStream(DemuxerStream::AUDIO));
 }
 
 class Mp3SeekFFmpegDemuxerTest
     : public FFmpegDemuxerTest,
       public testing::WithParamInterface<const char*> {
 };
 TEST_P(Mp3SeekFFmpegDemuxerTest, TestFastSeek) {
   // Init demxuer with given MP3 file parameter.
   CreateDemuxer(GetParam());
   InitializeDemuxer();
 
   // We read a bunch of bytes when we first open the file. Reset the count
   // here to just track the bytes read for the upcoming seek. This allows us
   // to use a more narrow threshold for passing the test.
   data_source_->reset_bytes_read_for_testing();
 
-  FFmpegDemuxerStream* audio = static_cast<FFmpegDemuxerStream*>(
-    demuxer_->GetStream(DemuxerStream::AUDIO));
+  FFmpegDemuxerStream* audio =
+      static_cast<FFmpegDemuxerStream*>(GetStream(DemuxerStream::AUDIO));
   ASSERT_TRUE(audio);
 
   // Seek to near the end of the file
   WaitableMessageLoopEvent event;
   demuxer_->Seek(.9 * audio->duration(), event.GetPipelineStatusCB());
   event.RunAndWaitForStatus(PIPELINE_OK);
 
   // Verify that seeking to the end read only a small portion of the file.
   // Slow seeks that read sequentially up to the seek point will read too many
   // bytes and fail this check.
@@ skipping 47 matching lines @@
     "bear-1280x720-av_frag.mp4",
     "bear-1280x720-av_with-aud-nalus_frag.mp4"
   };
 
   for (size_t i = 0; i < arraysize(files); ++i) {
     DVLOG(1) << "Testing " << files[i];
     CreateDemuxer(files[i]);
     InitializeDemuxer();
 
     // Ensure the expected streams are present.
-    DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+    DemuxerStream* stream = GetStream(DemuxerStream::VIDEO);
     ASSERT_TRUE(stream);
     stream->EnableBitstreamConverter();
 
     stream->Read(base::Bind(&ValidateAnnexB, stream));
     base::RunLoop().Run();
 
     demuxer_->Stop();
     demuxer_.reset();
     data_source_.reset();
   }
 }
 
 TEST_F(FFmpegDemuxerTest, Rotate_Metadata_0) {
   CreateDemuxer("bear_rotate_0.mp4");
   InitializeDemuxer();
 
-  DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* stream = GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(stream);
   ASSERT_EQ(VIDEO_ROTATION_0, stream->video_rotation());
 }
 
 TEST_F(FFmpegDemuxerTest, Rotate_Metadata_90) {
   CreateDemuxer("bear_rotate_90.mp4");
   InitializeDemuxer();
 
-  DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* stream = GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(stream);
   ASSERT_EQ(VIDEO_ROTATION_90, stream->video_rotation());
 }
 
 TEST_F(FFmpegDemuxerTest, Rotate_Metadata_180) {
   CreateDemuxer("bear_rotate_180.mp4");
   InitializeDemuxer();
 
-  DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* stream = GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(stream);
   ASSERT_EQ(VIDEO_ROTATION_180, stream->video_rotation());
 }
 
 TEST_F(FFmpegDemuxerTest, Rotate_Metadata_270) {
   CreateDemuxer("bear_rotate_270.mp4");
   InitializeDemuxer();
 
-  DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* stream = GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(stream);
   ASSERT_EQ(VIDEO_ROTATION_270, stream->video_rotation());
 }
 
 TEST_F(FFmpegDemuxerTest, NaturalSizeWithoutPASP) {
   CreateDemuxer("bear-640x360-non_square_pixel-without_pasp.mp4");
   InitializeDemuxer();
 
-  DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* stream = GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(stream);
 
   const VideoDecoderConfig& video_config = stream->video_decoder_config();
   EXPECT_EQ(gfx::Size(639, 360), video_config.natural_size());
 }
 
 TEST_F(FFmpegDemuxerTest, NaturalSizeWithPASP) {
   CreateDemuxer("bear-640x360-non_square_pixel-with_pasp.mp4");
   InitializeDemuxer();
 
-  DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* stream = GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(stream);
 
   const VideoDecoderConfig& video_config = stream->video_decoder_config();
   EXPECT_EQ(gfx::Size(639, 360), video_config.natural_size());
 }
 
 TEST_F(FFmpegDemuxerTest, HEVC_in_MP4_container) {
   CreateDemuxer("bear-hevc-frag.mp4");
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
   InitializeDemuxer();
 
-  DemuxerStream* video = demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* video = GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(video);
 
   video->Read(NewReadCB(FROM_HERE, 3569, 66733, true));
   base::RunLoop().Run();
 
   video->Read(NewReadCB(FROM_HERE, 1042, 200200, false));
   base::RunLoop().Run();
 #else
   InitializeDemuxerAndExpectPipelineStatus(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
 #endif
 }
 
 TEST_F(FFmpegDemuxerTest, Read_AC3_Audio) {
   CreateDemuxer("bear-ac3-only-frag.mp4");
 #if BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
   InitializeDemuxer();
 
   // Attempt a read from the audio stream and run the message loop until done.
-  DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
 
   // Read the first two frames and check that we are getting expected data
   audio->Read(NewReadCB(FROM_HERE, 834, 0, true));
   base::RunLoop().Run();
 
   audio->Read(NewReadCB(FROM_HERE, 836, 34830, true));
   base::RunLoop().Run();
 #else
   InitializeDemuxerAndExpectPipelineStatus(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
 #endif
 }
 
 TEST_F(FFmpegDemuxerTest, Read_EAC3_Audio) {
   CreateDemuxer("bear-eac3-only-frag.mp4");
 #if BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
   InitializeDemuxer();
 
   // Attempt a read from the audio stream and run the message loop until done.
-  DemuxerStream* audio = demuxer_->GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* audio = GetStream(DemuxerStream::AUDIO);
 
   // Read the first two frames and check that we are getting expected data
   audio->Read(NewReadCB(FROM_HERE, 870, 0, true));
   base::RunLoop().Run();
 
   audio->Read(NewReadCB(FROM_HERE, 872, 34830, true));
   base::RunLoop().Run();
 #else
   InitializeDemuxerAndExpectPipelineStatus(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
 #endif
@@ skipping 158 matching lines @@
     EXPECT_FALSE(base::Time::FromUTCString(date_string, &result))
         << "date_string '" << date_string << "'";
   }
 }
 
 TEST_F(FFmpegDemuxerTest, Read_Flac) {
   CreateDemuxer("sfx.flac");
   InitializeDemuxer();
 
   // Video stream should not be present.
-  EXPECT_EQ(nullptr, demuxer_->GetStream(DemuxerStream::VIDEO));
+  EXPECT_EQ(nullptr, GetStream(DemuxerStream::VIDEO));
 
   // Audio stream should be present.
-  DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* stream = GetStream(DemuxerStream::AUDIO);
   ASSERT_TRUE(stream);
   EXPECT_EQ(DemuxerStream::AUDIO, stream->type());
 
   const AudioDecoderConfig& audio_config = stream->audio_decoder_config();
   EXPECT_EQ(kCodecFLAC, audio_config.codec());
   EXPECT_EQ(32, audio_config.bits_per_channel());
   EXPECT_EQ(CHANNEL_LAYOUT_MONO, audio_config.channel_layout());
   EXPECT_EQ(44100, audio_config.samples_per_second());
   EXPECT_EQ(kSampleFormatS32, audio_config.sample_format());
 }
 
 // Verify that FFmpeg demuxer falls back to choosing disabled streams for
 // seeking if there's no suitable enabled stream found.
 TEST_F(FFmpegDemuxerTest, Seek_FallbackToDisabledVideoStream) {
   // Input has only video stream, no audio.
   CreateDemuxer("bear-320x240-video-only.webm");
   InitializeDemuxer();
-  EXPECT_EQ(nullptr, demuxer_->GetStream(DemuxerStream::AUDIO));
-  DemuxerStream* vstream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  EXPECT_EQ(nullptr, GetStream(DemuxerStream::AUDIO));
+  DemuxerStream* vstream = GetStream(DemuxerStream::VIDEO);
   EXPECT_NE(nullptr, vstream);
   EXPECT_EQ(vstream, preferred_seeking_stream(base::TimeDelta()));
 
   // Now pretend that video stream got disabled, e.g. due to current tab going
   // into background.
   vstream->set_enabled(false, base::TimeDelta());
   // Since there's no other enabled streams, the preferred seeking stream should
   // still be the video stream.
   EXPECT_EQ(vstream, preferred_seeking_stream(base::TimeDelta()));
 }
 
 TEST_F(FFmpegDemuxerTest, Seek_FallbackToDisabledAudioStream) {
   CreateDemuxer("bear-320x240-audio-only.webm");
   InitializeDemuxer();
-  DemuxerStream* astream = demuxer_->GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* astream = GetStream(DemuxerStream::AUDIO);
   EXPECT_NE(nullptr, astream);
-  EXPECT_EQ(nullptr, demuxer_->GetStream(DemuxerStream::VIDEO));
+  EXPECT_EQ(nullptr, GetStream(DemuxerStream::VIDEO));
   EXPECT_EQ(astream, preferred_seeking_stream(base::TimeDelta()));
 
   // Now pretend that audio stream got disabled.
   astream->set_enabled(false, base::TimeDelta());
   // Since there's no other enabled streams, the preferred seeking stream should
   // still be the audio stream.
   EXPECT_EQ(astream, preferred_seeking_stream(base::TimeDelta()));
 }
 
 }  // namespace media