Fix MSE garbage collection for disabled media tracks

media/test/pipeline_integration_test.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 <memory>
 #include <utility>
 
@@ skipping 522 matching lines @@
         chunk_demuxer_->AppendData(kSourceId, pData, size, append_window_start,
                                    append_window_end, &timestamp_offset));
     last_timestamp_offset_ = timestamp_offset;
   }
 
   void SetMemoryLimits(size_t limit_bytes) {
     chunk_demuxer_->SetMemoryLimitsForTest(DemuxerStream::AUDIO, limit_bytes);
     chunk_demuxer_->SetMemoryLimitsForTest(DemuxerStream::VIDEO, limit_bytes);
   }
 
-  void EvictCodedFrames(base::TimeDelta currentMediaTime, size_t newDataSize) {
-    chunk_demuxer_->EvictCodedFrames(kSourceId, currentMediaTime, newDataSize);
+  bool EvictCodedFrames(base::TimeDelta currentMediaTime, size_t newDataSize) {
+    return chunk_demuxer_->EvictCodedFrames(kSourceId, currentMediaTime,
+                                            newDataSize);
   }
 
   void RemoveRange(base::TimeDelta start, base::TimeDelta end) {
     chunk_demuxer_->Remove(kSourceId, start, end);
   }
 
   void EndOfStream() { chunk_demuxer_->MarkEndOfStream(PIPELINE_OK); }
 
   void Shutdown() {
     if (!chunk_demuxer_)
@@ skipping 1003 matching lines @@
 
     buffered_ranges = pipeline_->GetBufferedTimeRanges();
   } while (buffered_ranges.size() == 1 &&
            buffered_ranges.start(0) == base::TimeDelta::FromSeconds(0));
 
   EXPECT_EQ(1u, buffered_ranges.size());
   source.Shutdown();
   Stop();
 }
 
+TEST_F(PipelineIntegrationTest, MediaSource_GCWithDisabledVideoStream) {
+  const char* input_filename = "bear-320x240.webm";
+  MockMediaSource source(input_filename, kWebM, kAppendWholeFile);
+  EXPECT_EQ(PIPELINE_OK, StartPipelineWithMediaSource(&source));
+  scoped_refptr<DecoderBuffer> file = ReadTestDataFile(input_filename);
+  // The input file contains audio + video data. Assuming video data size is
+  // larger than audio, so setting memory limits to half of file data_size will
+  // ensure that video SourceBuffer is above memory limit and the audio
+  // SourceBuffer is below the memory limit.
+  source.SetMemoryLimits(file->data_size() / 2);
+
+  // Disable the video track and start playback. Renderer won't read from the
+  // disabled video stream, so the video stream read position should be 0.
+  pipeline_->OnSelectedVideoTrackChanged(base::nullopt);
+  Play();
+
+  // Wait until audio playback advances past 2 seconds and call MSE GC algorithm
+  // to prepare for more data to be appended.
+  base::TimeDelta media_time = base::TimeDelta::FromSeconds(2);
+  ASSERT_TRUE(WaitUntilCurrentTimeIsAfter(media_time));
+  // At this point the video SourceBuffer is over the memory limit (see the
+  // SetMemoryLimits comment above), but MSE GC should be able to remove some
+  // of video data and return true indicating success, even though no data has
+  // been read from the disabled video stream and its read position is 0.
+  ASSERT_TRUE(source.EvictCodedFrames(media_time, 10));
+
+  source.Shutdown();
+  Stop();
+}
+
 TEST_F(PipelineIntegrationTest,
        MAYBE_EME(MediaSource_ConfigChange_Encrypted_WebM)) {
   MockMediaSource source("bear-320x240-16x9-aspect-av_enc-av.webm", kWebM,
                          kAppendWholeFile);
   FakeEncryptedMedia encrypted_media(new KeyProvidingApp());
   EXPECT_EQ(PIPELINE_OK,
             StartPipelineWithEncryptedMedia(&source, &encrypted_media));
 
   EXPECT_CALL(*this, OnVideoNaturalSizeChange(gfx::Size(640, 360))).Times(1);
   scoped_refptr<DecoderBuffer> second_file =
@@ skipping 1093 matching lines @@
 
 TEST_F(PipelineIntegrationTest, BasicPlaybackPositiveStartTime) {
   ASSERT_EQ(PIPELINE_OK, Start("nonzero-start-time.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   ASSERT_EQ(base::TimeDelta::FromMicroseconds(396000),
             demuxer_->GetStartTime());
 }
 
 }  // namespace media