Fix ChunkDemuxer so it properly outputs buffered ranges.

media/filters/source_buffer_stream_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/source_buffer_stream.h"
 
 #include "base/logging.h"
 #include "media/base/data_buffer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 37 matching lines @@
   void AppendBuffers_ExpectFailure(
       int starting_position, int number_of_buffers) {
     AppendBuffers(starting_position, number_of_buffers,
                   base::TimeDelta(), false, NULL, 0);
   }
 
   void Seek(int position) {
     stream_.Seek(position * frame_duration_);
   }
 
-  SourceBufferStream::Timespan CreateTimespan(
-      int start_position, int end_position) {
-    return std::make_pair(
-        start_position * frame_duration_, (end_position + 1) * frame_duration_);
-  }
+  void CheckExpectedRanges(const std::string& expected) {
+    Ranges<base::TimeDelta> r = stream_.GetBufferedTime();
 
-  void CheckExpectedTimespan(int start_position, int end_position) {
-    SourceBufferStream::TimespanList expected;
-    expected.push_back(CreateTimespan(start_position, end_position));
-    CheckExpectedTimespans(expected);
-  }
-
-  void CheckExpectedTimespans(
-      SourceBufferStream::TimespanList expected_times) {
-    SourceBufferStream::TimespanList actual_times = stream_.GetBufferedTime();
-    EXPECT_EQ(expected_times.size(), actual_times.size());
-
-    for (SourceBufferStream::TimespanList::iterator actual_itr =
-         actual_times.begin(), expected_itr = expected_times.begin();
-         actual_itr != actual_times.end() &&
-         expected_itr != expected_times.end();
-         actual_itr++, expected_itr++) {
-      EXPECT_EQ(expected_itr->first / frame_duration_,
-                actual_itr->first / frame_duration_);
-      EXPECT_EQ(expected_itr->second / frame_duration_,
-                actual_itr->second / frame_duration_);
+    std::stringstream ss;
+    ss << "{ ";
+    for (size_t i = 0; i < r.size(); ++i) {
+      int64 start = (r.start(i) / frame_duration_);
+      int64 end = (r.end(i) / frame_duration_) - 1;
+      ss << "[" << start << "," << end << ") ";
     }
+    ss << "}";
+    EXPECT_EQ(ss.str(), expected);
   }
 
   void CheckExpectedBuffers(
       int starting_position, int ending_position) {
     CheckExpectedBuffers(starting_position, ending_position, false, NULL, 0);
   }
 
   void CheckExpectedBuffers(
       int starting_position, int ending_position, bool expect_keyframe) {
     CheckExpectedBuffers(starting_position, ending_position, expect_keyframe,
@@ skipping 85 matching lines @@
   int keyframes_per_second_;
   base::TimeDelta frame_duration_;
   DISALLOW_COPY_AND_ASSIGN(SourceBufferStreamTest);
 };
 
 TEST_F(SourceBufferStreamTest, Append_SingleRange) {
   // Append 15 buffers at positions 0 through 14.
   AppendBuffers(0, 15);
 
   // Check expected range.
-  CheckExpectedTimespan(0, 14);
+  CheckExpectedRanges("{ [0,14) }");
   // Check buffers in range.
   Seek(0);
   CheckExpectedBuffers(0, 14);
 }
 
 TEST_F(SourceBufferStreamTest, Append_SingleRange_OneBufferAtATime) {
   // Append 15 buffers starting at position 0, one buffer at a time.
   for (int i = 0; i < 15; i++)
     AppendBuffers(i, 1);
 
   // Check expected range.
-  CheckExpectedTimespan(0, 14);
+  CheckExpectedRanges("{ [0,14) }");
   // Check buffers in range.
   Seek(0);
   CheckExpectedBuffers(0, 14);
 }
 
 TEST_F(SourceBufferStreamTest, Append_DisjointRanges) {
   // Append 5 buffers at positions 0 through 4.
   AppendBuffers(0, 5);
 
   // Append 10 buffers at positions 15 through 24.
   AppendBuffers(15, 10);
 
   // Check expected ranges.
-  SourceBufferStream::TimespanList expected;
-  expected.push_back(CreateTimespan(0, 4));
-  expected.push_back(CreateTimespan(15, 24));
-  CheckExpectedTimespans(expected);
+  CheckExpectedRanges("{ [0,4) [15,24) }");
   // Check buffers in ranges.
   Seek(0);
   CheckExpectedBuffers(0, 4);
   Seek(15);
   CheckExpectedBuffers(15, 24);
 }
 
 TEST_F(SourceBufferStreamTest, Append_AdjacentRanges) {
   // Append 12 buffers at positions 0 through 11.
   AppendBuffers(0, 12);
 
   // Append 11 buffers at positions 15 through 25.
   AppendBuffers(15, 11);
 
   // Append 3 buffers at positions 12 through 14 to bridge the gap.
   AppendBuffers(12, 3);
 
   // Check expected range.
-  CheckExpectedTimespan(0, 25);
+  CheckExpectedRanges("{ [0,25) }");
   // Check buffers in range.
   Seek(0);
   CheckExpectedBuffers(0, 25);
 }
 
 TEST_F(SourceBufferStreamTest, Append_DoesNotBeginWithKeyframe) {
   // Append fails because the range doesn't begin with a keyframe.
   AppendBuffers_ExpectFailure(3, 5);
 
   // Append 10 buffers at positions 5 through 14.
   AppendBuffers(5, 10);
 
   // Check expected range.
-  CheckExpectedTimespan(5, 14);
+  CheckExpectedRanges("{ [5,14) }");
   // Check buffers in range.
   Seek(5);
   CheckExpectedBuffers(5, 14);
 
   // Append fails because the range doesn't begin with a keyframe.
   AppendBuffers_ExpectFailure(17, 10);
-  CheckExpectedTimespan(5, 14);
+  CheckExpectedRanges("{ [5,14) }");
   Seek(5);
   CheckExpectedBuffers(5, 14);
 }
 
 TEST_F(SourceBufferStreamTest, Complete_Overlap) {
   // Append 5 buffers at positions 5 through 9.
   AppendBuffers(5, 5);
 
   // Append 15 buffers at positions 0 through 14.
   AppendBuffers(0, 15);
 
   // Check expected range.
-  CheckExpectedTimespan(0, 14);
+  CheckExpectedRanges("{ [0,14) }");
   // Check buffers in range.
   Seek(0);
   CheckExpectedBuffers(0, 14);
 }
 
 TEST_F(SourceBufferStreamTest, Complete_Overlap_EdgeCase) {
   // Make each frame a keyframe so that it's okay to overlap frames at any point
   // (instead of needing to respect keyframe boundaries).
   SetStreamInfo(30, 30);
 
   // Append 6 buffers at positions 6 through 11.
   AppendBuffers(6, 6);
 
   // Append 8 buffers at positions 5 through 12.
   AppendBuffers(5, 8);
 
   // Check expected range.
-  CheckExpectedTimespan(5, 12);
+  CheckExpectedRanges("{ [5,12) }");
   // Check buffers in range.
   Seek(5);
   CheckExpectedBuffers(5, 12);
 }
 
 TEST_F(SourceBufferStreamTest, Start_Overlap) {
   // Append 5 buffers at positions 5 through 9.
   AppendBuffers(5, 5);
 
   // Append 6 buffers at positions 8 through 13.
   AppendBuffers(8, 6);
 
   // Check expected range.
-  CheckExpectedTimespan(5, 13);
+  CheckExpectedRanges("{ [5,13) }");
   // Check buffers in range.
   Seek(5);
   CheckExpectedBuffers(5, 13);
 }
 
 TEST_F(SourceBufferStreamTest, End_Overlap) {
   // Append 10 buffers at positions 10 through 19.
   AppendBuffers(10, 10);
 
   // Append 10 buffers at positions 5 through 14.
   AppendBuffers(5, 10);
 
   // Check expected range.
-  CheckExpectedTimespan(5, 19);
+  CheckExpectedRanges("{ [5,19) }");
   // Check buffers in range.
   Seek(5);
   CheckExpectedBuffers(5, 19);
 }
 
 TEST_F(SourceBufferStreamTest, End_Overlap_Several) {
   // Append 10 buffers at positions 10 through 19.
   AppendBuffers(10, 10);
 
   // Append 8 buffers at positions 5 through 12.
   AppendBuffers(5, 8);
 
   // Check expected ranges: stream should not have kept buffers 13 and 14
   // because the keyframe on which they depended was overwritten.
-  SourceBufferStream::TimespanList expected;
-  expected.push_back(CreateTimespan(5, 12));
-  expected.push_back(CreateTimespan(15, 19));
-  CheckExpectedTimespans(expected);
+  CheckExpectedRanges("{ [5,12) [15,19) }");
 
   // Check buffers in range.
   Seek(5);
   CheckExpectedBuffers(5, 12);
   CheckNoNextBuffer();
 
   Seek(19);
   CheckExpectedBuffers(15, 19);
 }
 
 TEST_F(SourceBufferStreamTest, Complete_Overlap_Several) {
   // Append 2 buffers at positions 5 through 6.
   AppendBuffers(5, 2);
 
   // Append 2 buffers at positions 10 through 11.
   AppendBuffers(10, 2);
 
   // Append 2 buffers at positions 15 through 16.
   AppendBuffers(15, 2);
 
   // Check expected ranges.
-  SourceBufferStream::TimespanList expected;
-  expected.push_back(CreateTimespan(5, 6));
-  expected.push_back(CreateTimespan(10, 11));
-  expected.push_back(CreateTimespan(15, 16));
-  CheckExpectedTimespans(expected);
+  CheckExpectedRanges("{ [5,6) [10,11) [15,16) }");
 
   // Append buffers at positions 0 through 19.
   AppendBuffers(0, 20);
 
   // Check expected range.
-  expected.clear();
-  expected.push_back(CreateTimespan(0, 19));
-  CheckExpectedTimespans(expected);
+  CheckExpectedRanges("{ [0,19) }");
   // Check buffers in range.
   Seek(0);
   CheckExpectedBuffers(0, 19);
 }
 
 TEST_F(SourceBufferStreamTest, Complete_Overlap_Several_Then_Merge) {
   // Append 2 buffers at positions 5 through 6.
   AppendBuffers(5, 2);
 
   // Append 2 buffers at positions 10 through 11.
   AppendBuffers(10, 2);
 
   // Append 2 buffers at positions 15 through 16.
   AppendBuffers(15, 2);
 
   // Append 2 buffers at positions 20 through 21.
   AppendBuffers(20, 2);
 
   // Append buffers at positions 0 through 19.
   AppendBuffers(0, 20);
 
   // Check expected ranges.
-  CheckExpectedTimespan(0, 21);
+  CheckExpectedRanges("{ [0,21) }");
   // Check buffers in range.
   Seek(0);
   CheckExpectedBuffers(0, 21);
 }
 
 TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected) {
   // Append 10 buffers at positions 5 through 14.
   AppendBuffers(5, 10, &kDataA);
 
   // Seek to buffer at position 5.
   Seek(5);
 
   // Replace old data with new data.
   AppendBuffers(5, 10, &kDataB);
 
-  // Check timespans are correct.
-  CheckExpectedTimespan(5, 14);
+  // Check ranges are correct.
+  CheckExpectedRanges("{ [5,14) }");
 
   // Check that data has been replaced with new data.
   CheckExpectedBuffers(5, 14, &kDataB);
 }
 
 // This test is testing that a client can append data to SourceBufferStream that
 // overlaps the range from which the client is currently grabbing buffers. We
 // would expect that the SourceBufferStream would return old data until it hits
 // the keyframe of the new data, after which it will return the new data.
 TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected_TrackBuffer) {
   // Append 10 buffers at positions 5 through 14.
   AppendBuffers(5, 10, &kDataA);
 
   // Seek to buffer at position 5 and get next buffer.
   Seek(5);
   CheckExpectedBuffers(5, 5, &kDataA);
 
   // Do a complete overlap by appending 20 buffers at positions 0 through 19.
   AppendBuffers(0, 20, &kDataB);
 
-  // Check timespan is correct.
-  CheckExpectedTimespan(0, 19);
+  // Check range is correct.
+  CheckExpectedRanges("{ [0,19) }");
 
   // Expect old data up until next keyframe in new data.
   CheckExpectedBuffers(6, 9, &kDataA);
   CheckExpectedBuffers(10, 10, &kDataB, true);
 
   // Expect rest of data to be new.
   CheckExpectedBuffers(11, 19, &kDataB);
 
   // Seek back to beginning; all data should be new.
   Seek(0);
   CheckExpectedBuffers(0, 19, &kDataB);
 
-  // Check timespan continues to be correct.
-  CheckExpectedTimespan(0, 19);
+  // Check range continues to be correct.
+  CheckExpectedRanges("{ [0,19) }");
 }
 
 TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected_EdgeCase) {
   // Append 10 buffers at positions 5 through 14.
   AppendBuffers(5, 10, &kDataA);
 
   // Seek to buffer at position 5 and get next buffer.
   Seek(5);
   CheckExpectedBuffers(5, 5, &kDataA);
 
   // Replace existing data with new data.
   AppendBuffers(5, 10, &kDataB);
 
-  // Check timespans are correct.
-  CheckExpectedTimespan(5, 14);
+  // Check ranges are correct.
+  CheckExpectedRanges("{ [5,14) }");
 
   // Expect old data up until next keyframe in new data.
   CheckExpectedBuffers(6, 9, &kDataA);
   CheckExpectedBuffers(10, 10, &kDataB, true);
 
   // Expect rest of data to be new.
   CheckExpectedBuffers(11, 14, &kDataB);
 
   // Seek back to beginning; all data should be new.
   Seek(5);
   CheckExpectedBuffers(5, 14, &kDataB);
 
-  // Check timespan continues to be correct.
-  CheckExpectedTimespan(5, 14);
+  // Check range continues to be correct.
+  CheckExpectedRanges("{ [5,14) }");
 }
 
 TEST_F(SourceBufferStreamTest, Complete_Overlap_Selected_Multiple) {
   static const uint8 kDataC = 0x55;
   static const uint8 kDataD = 0x77;
 
   // Append 5 buffers at positions 5 through 9.
   AppendBuffers(5, 5, &kDataA);
 
   // Seek to buffer at position 5 and get next buffer.
@@ skipping 27 matching lines @@
 
 TEST_F(SourceBufferStreamTest, Start_Overlap_Selected) {
   // Append 10 buffers at positions 0 through 9.
   AppendBuffers(0, 10, &kDataA);
 
   // Seek to position 5, then add buffers to overlap data at that position.
   Seek(5);
   AppendBuffers(5, 10, &kDataB);
 
   // Check expected range.
-  CheckExpectedTimespan(0, 14);
+  CheckExpectedRanges("{ [0,14) }");
 
   // Because we seeked to a keyframe, the next buffers should all be new data.
   CheckExpectedBuffers(5, 14, &kDataB);
 
   // Make sure all data is correct.
   Seek(0);
   CheckExpectedBuffers(0, 4, &kDataA);
   CheckExpectedBuffers(5, 14, &kDataB);
 }
 
 TEST_F(SourceBufferStreamTest, Start_Overlap_Selected_TrackBuffer) {
   // Append 15 buffers at positions 0 through 14.
   AppendBuffers(0, 15, &kDataA);
 
   // Seek to 10 and get buffer.
   Seek(10);
   CheckExpectedBuffers(10, 10, &kDataA);
 
   // Now append 10 buffers of new data at positions 10 through 19.
   AppendBuffers(10, 10, &kDataB);
 
   // Check expected range.
-  CheckExpectedTimespan(0, 19);
+  CheckExpectedRanges("{ [0,19) }");
 
   // The next 4 buffers should be a from the old buffer, followed by a keyframe
   // from the new data.
   CheckExpectedBuffers(11, 14, &kDataA);
   CheckExpectedBuffers(15, 15, &kDataB, true);
 
   // The rest of the buffers should be new data.
   CheckExpectedBuffers(16, 19, &kDataB);
 
   // Now seek to the beginning; positions 0 through 9 should be the original
   // data, positions 10 through 19 should be the new data.
   Seek(0);
   CheckExpectedBuffers(0, 9, &kDataA);
   CheckExpectedBuffers(10, 19, &kDataB);
 
-  // Make sure timespan is still correct.
-  CheckExpectedTimespan(0, 19);
+  // Make sure range is still correct.
+  CheckExpectedRanges("{ [0,19) }");
 }
 
 TEST_F(SourceBufferStreamTest, Start_Overlap_Selected_EdgeCase) {
   // Append 10 buffers at positions 5 through 14.
   AppendBuffers(5, 10, &kDataA);
 
   Seek(10);
   CheckExpectedBuffers(10, 10, &kDataA);
 
   // Now replace the last 5 buffers with new data.
   AppendBuffers(10, 5, &kDataB);
 
   // The next 4 buffers should be the origial data, held in the track buffer.
   CheckExpectedBuffers(11, 14, &kDataA);
 
   // The next buffer is at position 15, so we should fail to fulfill the
   // request.
   CheckNoNextBuffer();
 
   // Now append data at 15 through 19 and check to make sure it's correct.
   AppendBuffers(15, 5, &kDataB);
   CheckExpectedBuffers(15, 19, &kDataB);
 
   // Seek to beginning of buffered range and check buffers.
   Seek(5);
   CheckExpectedBuffers(5, 9, &kDataA);
   CheckExpectedBuffers(10, 19, &kDataB);
 
   // Check expected range.
-  CheckExpectedTimespan(5, 19);
+  CheckExpectedRanges("{ [5,19) }");
 }
 
 // This test covers the case where new buffers end-overlap an existing, selected
 // range, and the next buffer is a keyframe that's being overlapped by new
 // buffers.
 // index:  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
 // old  :           *A*a a a a A a a a a
 // new  :  B b b b b B b b b b
 // after:  B b b b b*B*b b b b A a a a a
 TEST_F(SourceBufferStreamTest, End_Overlap_Selected) {
   // Append 10 buffers at positions 5 through 14.
   AppendBuffers(5, 10, &kDataA);
 
   // Seek to position 5.
   Seek(5);
 
   // Now append 10 buffers at positions 0 through 9.
   AppendBuffers(0, 10, &kDataB);
 
   // Check expected range.
-  CheckExpectedTimespan(0, 14);
+  CheckExpectedRanges("{ [0,14) }");
 
   // Because we seeked to a keyframe, the next buffers should be new.
   CheckExpectedBuffers(5, 9, &kDataB);
 
   // Make sure all data is correct.
   Seek(0);
   CheckExpectedBuffers(0, 9, &kDataB);
   CheckExpectedBuffers(10, 14, &kDataA);
 }
 
@@ skipping 10 matching lines @@
   AppendBuffers(5, 10, &kDataA);
 
   // Seek to position 10, then move to position 13.
   Seek(10);
   CheckExpectedBuffers(10, 12, &kDataA);
 
   // Now append 10 buffers at positions 0 through 9.
   AppendBuffers(0, 10, &kDataB);
 
   // Check expected range.
-  CheckExpectedTimespan(0, 14);
+  CheckExpectedRanges("{ [0,14) }");
 
   // Make sure rest of data is as expected.
   CheckExpectedBuffers(13, 14, &kDataA);
 
   // Make sure all data is correct.
   Seek(0);
   CheckExpectedBuffers(0, 9, &kDataB);
   CheckExpectedBuffers(10, 14, &kDataA);
 }
 
@@ skipping 11 matching lines @@
   AppendBuffers(5, 10, &kDataA);
 
   // Seek to position 10, then move to position 13.
   Seek(10);
   CheckExpectedBuffers(10, 12, &kDataA);
 
   // Now append 8 buffers at positions 0 through 7.
   AppendBuffers(0, 8, &kDataB);
 
   // Check expected ranges.
-  SourceBufferStream::TimespanList expected;
-  expected.push_back(CreateTimespan(0, 7));
-  expected.push_back(CreateTimespan(10, 14));
-  CheckExpectedTimespans(expected);
+  CheckExpectedRanges("{ [0,7) [10,14) }");
 
   // Make sure rest of data is as expected.
   CheckExpectedBuffers(13, 14, &kDataA);
 
   // Make sure all data is correct.
   Seek(0);
   CheckExpectedBuffers(0, 7, &kDataB);
   CheckNoNextBuffer();
 
   Seek(10);
@@ skipping 15 matching lines @@
   AppendBuffers(5, 10, &kDataA);
 
   // Seek to position 5, then move to position 8.
   Seek(5);
   CheckExpectedBuffers(5, 7, &kDataA);
 
   // Now append 8 buffers at positions 0 through 7.
   AppendBuffers(0, 8, &kDataB);
 
   // Check expected ranges.
-  SourceBufferStream::TimespanList expected;
-  expected.push_back(CreateTimespan(0, 7));
-  expected.push_back(CreateTimespan(10, 14));
-  CheckExpectedTimespans(expected);
+  CheckExpectedRanges("{ [0,7) [10,14) }");
 
   // Check for data in the track buffer.
   CheckExpectedBuffers(8, 9, &kDataA);
   // The buffer immediately after the track buffer should be a keyframe.
   CheckExpectedBuffers(10, 10, &kDataA, true);
 
   // Make sure all data is correct.
   Seek(0);
   CheckExpectedBuffers(0, 7, &kDataB);
   Seek(10);
@@ skipping 14 matching lines @@
   AppendBuffers(5, 10, &kDataA);
 
   // Seek to position 5, then move to position 8.
   Seek(5);
   CheckExpectedBuffers(5, 7, &kDataA);
 
   // Now append 10 buffers at positions 0 through 9.
   AppendBuffers(0, 10, &kDataB);
 
   // Check expected range.
-  CheckExpectedTimespan(0, 14);
+  CheckExpectedRanges("{ [0,14) }");
 
   // Check for data in the track buffer.
   CheckExpectedBuffers(8, 9, &kDataA);
   // The buffer immediately after the track buffer should be a keyframe.
   CheckExpectedBuffers(10, 10, &kDataA, true);
 
   // Make sure all data is correct.
   Seek(0);
   CheckExpectedBuffers(0, 9, &kDataB);
   CheckExpectedBuffers(10, 14, &kDataA);
@@ skipping 14 matching lines @@
   AppendBuffers(5, 10, &kDataA);
 
   // Seek to position 5, then move to position 6.
   Seek(5);
   CheckExpectedBuffers(5, 5, &kDataA);
 
   // Now append 7 buffers at positions 0 through 6.
   AppendBuffers(0, 7, &kDataB);
 
   // Check expected ranges.
-  SourceBufferStream::TimespanList expected;
-  expected.push_back(CreateTimespan(0, 6));
-  expected.push_back(CreateTimespan(10, 14));
-  CheckExpectedTimespans(expected);
+  CheckExpectedRanges("{ [0,6) [10,14) }");
 
   // Check for data in the track buffer.
   CheckExpectedBuffers(6, 9, &kDataA);
   // The buffer immediately after the track buffer should be a keyframe.
   CheckExpectedBuffers(10, 10, &kDataA, true);
 
   // Make sure all data is correct.
   Seek(0);
   CheckExpectedBuffers(0, 6, &kDataB);
   CheckNoNextBuffer();
@@ skipping 17 matching lines @@
   AppendBuffers(5, 15, &kDataA);
 
   // Seek to position 5, then move to position 6.
   Seek(5);
   CheckExpectedBuffers(5, 5, &kDataA);
 
   // Now append 13 buffers at positions 0 through 12.
   AppendBuffers(0, 13, &kDataB);
 
   // Check expected ranges.
-  SourceBufferStream::TimespanList expected;
-  expected.push_back(CreateTimespan(0, 12));
-  expected.push_back(CreateTimespan(15, 19));
-  CheckExpectedTimespans(expected);
+  CheckExpectedRanges("{ [0,12) [15,19) }");
 
   // Check for data in the track buffer.
   CheckExpectedBuffers(6, 9, &kDataA);
   // The buffer immediately after the track buffer should be a keyframe
   // from the new data.
   CheckExpectedBuffers(10, 10, &kDataB, true);
 
   // Make sure all data is correct.
   Seek(0);
   CheckExpectedBuffers(0, 12, &kDataB);
@@ skipping 15 matching lines @@
   AppendBuffers(5, 5, &kDataA);
 
   // Seek to position 5, then move to position 6.
   Seek(5);
   CheckExpectedBuffers(5, 5, &kDataA);
 
   // Now append 6 buffers at positions 0 through 5.
   AppendBuffers(0, 6, &kDataB);
 
   // Check expected range.
-  CheckExpectedTimespan(0, 5);
+  CheckExpectedRanges("{ [0,5) }");
 
   // Check for data in the track buffer.
   CheckExpectedBuffers(6, 9, &kDataA);
 
   // Now there's no data to fulfill the request.
   CheckNoNextBuffer();
 
   // Let's fill in the gap, buffers 6 through 10.
   AppendBuffers(6, 5, &kDataB);
 
@@ skipping 12 matching lines @@
   // Append 15 buffers at positions 0 through 14.
   AppendBuffers(0, 15, &kDataA);
 
   // Seek to position 5.
   Seek(5);
 
   // Now append 5 buffers at positions 5 through 9.
   AppendBuffers(5, 5, &kDataB);
 
   // Check expected range.
-  CheckExpectedTimespan(0, 14);
+  CheckExpectedRanges("{ [0,14) }");
 
   // Check for next data; should be new data.
   CheckExpectedBuffers(5, 9, &kDataB);
 
   // Make sure all data is correct.
   Seek(0);
   CheckExpectedBuffers(0, 4, &kDataA);
   CheckExpectedBuffers(5, 9, &kDataB);
   CheckExpectedBuffers(10, 14, &kDataA);
 }
@@ skipping 10 matching lines @@
   AppendBuffers(0, 15, &kDataA);
 
   // Seek to 10 then move to position 11.
   Seek(10);
   CheckExpectedBuffers(10, 10, &kDataA);
 
   // Now append 5 buffers at positions 5 through 9.
   AppendBuffers(5, 5, &kDataB);
 
   // Check expected range.
-  CheckExpectedTimespan(0, 14);
+  CheckExpectedRanges("{ [0,14) }");
 
   // Make sure data is correct.
   CheckExpectedBuffers(11, 14, &kDataA);
   Seek(0);
   CheckExpectedBuffers(0, 4, &kDataA);
   CheckExpectedBuffers(5, 9, &kDataB);
   CheckExpectedBuffers(10, 14, &kDataA);
 }
 
 // This test covers the case when new buffers overlap the middle of a selected
 // range. This tests the case when there is a split and the next buffer is
 // before the new buffers.
 // index:  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
 // old  :  A a*a*a a A a a a a A a a a a
 // new  :            B b b
 // after:  A a*a*a a B b b|   |A a a a a
 TEST_F(SourceBufferStreamTest, Middle_Overlap_Selected_3) {
   // Append 15 buffers at positions 0 through 14.
   AppendBuffers(0, 15, &kDataA);
 
   // Seek to beginning then move to position 2.
   Seek(0);
   CheckExpectedBuffers(0, 1, &kDataA);
 
   // Now append 3 buffers at positions 5 through 7.
   AppendBuffers(5, 3, &kDataB);
 
   // Check expected range.
-  SourceBufferStream::TimespanList expected;
-  expected.push_back(CreateTimespan(0, 7));
-  expected.push_back(CreateTimespan(10, 14));
-  CheckExpectedTimespans(expected);
+  CheckExpectedRanges("{ [0,7) [10,14) }");
 
   // Make sure data is correct.
   CheckExpectedBuffers(2, 4, &kDataA);
   CheckExpectedBuffers(5, 7, &kDataB);
   Seek(10);
   CheckExpectedBuffers(10, 14, &kDataA);
 }
 
 // This test covers the case when new buffers overlap the middle of a selected
 // range. This tests the case when there is a split and the next buffer is after
 // the new buffers but before the split range.
 // index:  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
 // old  :  A a a a a A a a*a*a A a a a a
 // new  :            B b b
 // after: |A a a a a B b b|   |A a a a a|
 // track:                 |a a|
 TEST_F(SourceBufferStreamTest, Middle_Overlap_Selected_4) {
   // Append 15 buffers at positions 0 through 14.
   AppendBuffers(0, 15, &kDataA);
 
   // Seek to 5 then move to position 8.
   Seek(5);
   CheckExpectedBuffers(5, 7, &kDataA);
 
   // Now append 3 buffers at positions 5 through 7.
   AppendBuffers(5, 3, &kDataB);
 
   // Check expected range.
-  SourceBufferStream::TimespanList expected;
-  expected.push_back(CreateTimespan(0, 7));
-  expected.push_back(CreateTimespan(10, 14));
-  CheckExpectedTimespans(expected);
+  CheckExpectedRanges("{ [0,7) [10,14) }");
 
   // Buffers 8 and 9 should be in the track buffer.
   CheckExpectedBuffers(8, 9, &kDataA);
   // The buffer immediately after the track buffer should be a keyframe.
   CheckExpectedBuffers(10, 10, &kDataA, true);
 
   // Make sure all data is correct.
   Seek(0);
   CheckExpectedBuffers(0, 4, &kDataA);
   CheckExpectedBuffers(5, 7, &kDataB);
@@ skipping 68 matching lines @@
   // Append 10 buffers at positions 5 through 14.
   AppendBuffers(5, 10, &kDataA);
 
   // Seek to buffer at position 5 and get next buffer.
   Seek(5);
   CheckExpectedBuffers(5, 5, &kDataA);
 
   // Do a complete overlap by appending 20 buffers at positions 0 through 19.
   AppendBuffers(0, 20, &kDataB);
 
-  // Check timespan is correct.
-  CheckExpectedTimespan(0, 19);
+  // Check range is correct.
+  CheckExpectedRanges("{ [0,19) }");
 
   // Seek to beginning; all data should be new.
   Seek(0);
   CheckExpectedBuffers(0, 19, &kDataB);
 
-  // Check timespan continues to be correct.
-  CheckExpectedTimespan(0, 19);
+  // Check range continues to be correct.
+  CheckExpectedRanges("{ [0,19) }");
 }
 
 TEST_F(SourceBufferStreamTest, Seek_StartOfSegment) {
   base::TimeDelta bump = frame_duration() / 4;
   CHECK(bump > base::TimeDelta());
 
   // Append 5 buffers at position (5 + |bump|) through 9, where the media
   // segment begins at position 5.
   AppendBuffers(5, 5, bump);
   scoped_refptr<StreamParserBuffer> buffer;
@@ skipping 24 matching lines @@
   // Append 5 buffers at positions 10 through 14.
   AppendBuffers(10, 5);
 
   // Seek to buffer at position 12.
   Seek(12);
 
   // Append 5 buffers at positions 5 through 9.
   AppendBuffers(5, 5);
 
   // Make sure ranges are merged.
-  CheckExpectedTimespan(5, 14);
+  CheckExpectedRanges("{ [5,14) }");
 
   // Make sure the next buffer is correct.
   CheckExpectedBuffers(10, 10);
 
   // Append 5 buffers at positions 15 through 19.
   AppendBuffers(15, 5);
-  CheckExpectedTimespan(5, 19);
+  CheckExpectedRanges("{ [5,19) }");
 
   // Make sure the remaining next buffers are correct.
   CheckExpectedBuffers(11, 14);
 }
 
 TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenAppend) {
   // Append 4 buffers at positions 0 through 3.
   AppendBuffers(0, 4);
 
   // Seek to buffer at position 0 and get all buffers.
@@ skipping 38 matching lines @@
 
 TEST_F(SourceBufferStreamTest, GetNextBuffer_NoSeek) {
   // Append 5 buffers at position 5.
   AppendBuffers(5, 5);
 
   // Should receive buffers from the start without needing to seek.
   CheckExpectedBuffers(5, 5);
 }
 
 }  // namespace media