Fix MSE GC, make it less aggressive, more spec-compliant

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/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
@@ skipping 158 matching lines @@
         base::Bind(&ChunkDemuxerTest::InitSegmentReceived,
                    base::Unretained(this));
     CreateNewDemuxer();
   }
 
   void CreateNewDemuxer() {
     base::Closure open_cb =
         base::Bind(&ChunkDemuxerTest::DemuxerOpened, base::Unretained(this));
     Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb = base::Bind(
         &ChunkDemuxerTest::OnEncryptedMediaInitData, base::Unretained(this));
+    current_playback_position_ = kNoTimestamp();
     demuxer_.reset(new ChunkDemuxer(
         open_cb, encrypted_media_init_data_cb, base::Bind(&AddLogEntryForTest),
+        base::Bind(&ChunkDemuxerTest::GetCurrentPlaybackPosition,
+                   base::Unretained(this)),
         scoped_refptr<MediaLog>(new MediaLog()), true));
   }
 
   virtual ~ChunkDemuxerTest() {
     ShutdownDemuxer();
   }
 
   void CreateInitSegment(int stream_flags,
                          bool is_audio_encrypted,
                          bool is_video_encrypted,
@@ skipping 985 matching lines @@
 
   bool SetTimestampOffset(const std::string& id,
                           base::TimeDelta timestamp_offset) {
     if (demuxer_->IsParsingMediaSegment(id))
       return false;
 
     timestamp_offset_map_[id] = timestamp_offset;
     return true;
   }
 
+  void SetCurrentPlaybackPosition(base::TimeDelta media_time) {
+    current_playback_position_ = media_time;
+  }
+
+  base::TimeDelta GetCurrentPlaybackPosition() {
+    return current_playback_position_;
+  }
+
   base::MessageLoop message_loop_;
   MockDemuxerHost host_;
 
   scoped_ptr<ChunkDemuxer> demuxer_;
   ChunkDemuxer::InitSegmentReceivedCB init_segment_received_cb_;
 
+  // Used to provide current playback position for ChunkDemuxer garbage
+  // collection algorithm.
+  base::TimeDelta current_playback_position_;
+
   base::TimeDelta append_window_start_for_next_append_;
   base::TimeDelta append_window_end_for_next_append_;
 
   // Map of source id to timestamp offset to use for the next AppendData()
   // operation for that source id.
   std::map<std::string, base::TimeDelta> timestamp_offset_map_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChunkDemuxerTest);
 };
@@ skipping 2125 matching lines @@
 
   // Append data to satisfy the seek.
   AppendCluster(seek_time.InMilliseconds(), 10);
 }
 
 TEST_F(ChunkDemuxerTest, SetMemoryLimitType) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   // Set different memory limits for audio and video.
   demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 10 * kBlockSize);
-  demuxer_->SetMemoryLimits(DemuxerStream::VIDEO, 5 * kBlockSize);
+  demuxer_->SetMemoryLimits(DemuxerStream::VIDEO, 5 * kBlockSize + 1);
 
   base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(1000);
 
   // Append data at the start that can be garbage collected:
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 0, 10);
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum, 0, 5);
 
+  // We should be right at buffer limit, should pass
+  EXPECT_TRUE(demuxer_->EvictFrames());
+
   CheckExpectedRanges(DemuxerStream::AUDIO, "{ [0,230) }");
   CheckExpectedRanges(DemuxerStream::VIDEO, "{ [0,165) }");
 
   // Seek so we can garbage collect the data appended above.
   Seek(seek_time);
 
   // Append data at seek_time.
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum,
                             seek_time.InMilliseconds(), 10);
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum,
                             seek_time.InMilliseconds(), 5);
 
+  // We should delete first append, and be exactly at buffer limit
+  EXPECT_TRUE(demuxer_->EvictFrames());
+
   // Verify that the old data, and nothing more, has been garbage collected.
   CheckExpectedRanges(DemuxerStream::AUDIO, "{ [1000,1230) }");
   CheckExpectedRanges(DemuxerStream::VIDEO, "{ [1000,1165) }");
 }
 
 TEST_F(ChunkDemuxerTest, GCDuringSeek) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
 
   demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 5 * kBlockSize);
 
   base::TimeDelta seek_time1 = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta seek_time2 = base::TimeDelta::FromMilliseconds(500);
 
   // Initiate a seek to |seek_time1|.
   Seek(seek_time1);
 
   // Append data to satisfy the first seek request.
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum,
                             seek_time1.InMilliseconds(), 5);
   CheckExpectedRanges(kSourceId, "{ [1000,1115) }");
 
   // Signal that the second seek is starting.
   demuxer_->StartWaitingForSeek(seek_time2);
 
-  // Append data to satisfy the second seek. This append triggers
-  // the garbage collection logic since we set the memory limit to
-  // 5 blocks.
+  // Append data to satisfy the second seek.
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum,
                             seek_time2.InMilliseconds(), 5);
 
+  // Should remove first append
+  EXPECT_TRUE(demuxer_->EvictFrames());
+
   // Verify that the buffers that cover |seek_time2| do not get
   // garbage collected.
   CheckExpectedRanges(kSourceId, "{ [500,615) }");
 
   // Complete the seek.
   demuxer_->Seek(seek_time2, NewExpectedStatusCB(PIPELINE_OK));
 
-
   // Append more data and make sure that the blocks for |seek_time2|
   // don't get removed.
-  //
-  // NOTE: The current GC algorithm tries to preserve the GOP at the
-  //  current position as well as the last appended GOP. This is
-  //  why there are 2 ranges in the expectations.
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 700, 5);
-  CheckExpectedRanges(kSourceId, "{ [500,592) [792,815) }");
+
+  // We should not delete things between head and last append, so buffer
+  // remains overfull.
+  EXPECT_FALSE(demuxer_->EvictFrames());
+
+  CheckExpectedRanges(kSourceId, "{ [500,615) [700,815) }");
+}
+
+TEST_F(ChunkDemuxerTest, GCKeepPlayhead) {
+  ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
+
+  // Set different memory limits for audio and video.
+  demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 5 * kBlockSize);
+
+  // Set media time to report playback head at 0ms
+  SetCurrentPlaybackPosition(base::TimeDelta::FromMilliseconds(0));
+
+  // Append data at the start that can be garbage collected:
+  AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 0, 10);
+
+  // We expect garbage collection to fail, as we don't want to spontaneously
+  // create gaps in source buffer stream. This could break playback for many

[wolenetz, 2015/06/04 20:06:50]

nit: s/This/Gaps/

[servolk, 2015/06/04 20:22:46]

Done.

+  // clients, who don't bother to check ranges after append.
+  EXPECT_FALSE(demuxer_->EvictFrames());
+  CheckExpectedRanges(kSourceId, "{ [0,230) }");
+
+  // Seek, confirm that media time holds us at zero
+  base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(207);
+  Seek(seek_time);
+
+  EXPECT_FALSE(demuxer_->EvictFrames());
+  CheckExpectedRanges(kSourceId, "{ [0,230) }");
+
+  // Progress media time, show that we can collect up to that point
+  SetCurrentPlaybackPosition(base::TimeDelta::FromMilliseconds(69));
+  EXPECT_FALSE(demuxer_->EvictFrames());
+  CheckExpectedRanges(kSourceId, "{ [69,230) }");
 }
 
 TEST_F(ChunkDemuxerTest, AppendWindow_Video) {
   ASSERT_TRUE(InitDemuxer(HAS_VIDEO));
   DemuxerStream* stream = demuxer_->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);
 
@@ skipping 335 matching lines @@
 TEST_F(ChunkDemuxerTest, CuesBetweenClusters) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   AppendCluster(GenerateCluster(0, 0, 4));
   AppendData(kCuesHeader, sizeof(kCuesHeader));
   AppendCluster(GenerateCluster(46, 66, 5));
   CheckExpectedRanges(kSourceId, "{ [0,115) }");
 }
 
 }  // namespace media