Fix seeking back in the new MSE GC algorithm

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 3394 matching lines @@
   demuxer_->Seek(seek_time2, NewExpectedStatusCB(PIPELINE_OK));
 
   // Append more data and make sure that we preserve both the buffered range
   // around |seek_time2|, because that's the current playback position,
   // and the newly appended range, since this is the most recent append.
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 700, 5);
   EXPECT_FALSE(demuxer_->EvictCodedFrames(kSourceId, seek_time2, 0));
   CheckExpectedRanges(kSourceId, "{ [500,615) [700,815) }");
 }
 
+TEST_F(ChunkDemuxerTest, GCDuringSeekBack) {
+  ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
+  demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 10 * kBlockSize);
+  // Append some data at position 1000ms
+  AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 1000, 10);
+  CheckExpectedRanges(kSourceId, "{ [1000,1230) }");
+
+  // GC should be able to evict frames in the currently buffered range, since
+  // those frames are later than the seek target position 0.
+  base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(0);
+  EXPECT_TRUE(demuxer_->EvictCodedFrames(kSourceId, seek_time, 5 * kBlockSize));

[wolenetz, 2015/09/16 19:25:27]

nit: We could do a further check of expectation here that the resulting buffered
ranges after GC of 5 blocks is now { [ 1115,1230) } IIUC.

Also, it would be good to have a variety of related GC-while-unsatisfied-seek
tests:
1) this one
2) three buffered ranges, seek time is between first and second, last append is
at end of third range; ensure that GC can collect from front into the middle of
the third range (or maybe a 2b. case that also tests that *all* could be
collected).
3) a couple buffered ranges with seek time between them and last appended buffer
was at end of the *first* range.

I'm probably missing one or two major test details here, but you get the point:
I don't think we previously had nearly enough unsatisfied-seek-and-GC test
coverage. This one test is great; I would like more.

+}
+
 TEST_F(ChunkDemuxerTest, GCKeepPlayhead) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
 
   demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 5 * kBlockSize);
 
   // Append data at the start that can be garbage collected:
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 0, 10);
   CheckExpectedRanges(kSourceId, "{ [0,230) }");
 
   // We expect garbage collection to fail, as we don't want to spontaneously
@@ skipping 423 matching lines @@
   // audio size is 80 bytes, new data is 28 bytes, we need to remove just one 10
   // byte block to stay under 100 bytes memory limit after append
   // 80 - 10 + 28 = 98).
   // For video stream 150 + 52 = 202. Video limit is 150 bytes. We need to
   // remove at least 6 blocks to stay under limit.
   CheckExpectedBuffers(audio_stream, "40K 80K 120K 160K 200K 240K 280K");
   CheckExpectedBuffers(video_stream, "60K 70 80K 90 100K 110 120K 130 140K");
 }
 
 }  // namespace media