Update SourceBufferStream and its unit tests to always expect valid durations.

This change fixes the SourceBufferStream unit tests so that they always
provide valid durations for buffers that it passes to SourceBufferStream.
I've also added code to SoureBufferStream to verify that it always gets
buffers with valid durations.

Minor tweaks to test expectations were needed to compensate for the
SourceBufferStream behaving differently when it got actual durations instead
of using the durations it made up. In most cases I just used the duration
the SourceBufferStream was ultimately using. In a few cases the duration
the SourceBufferStream was generating didn't make any sense so I simply
changed the expectations to match the new behavior.

Review URL: https://codereview.chromium.org/379693002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@283365 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 111 insertions, 71 deletions

diff --git a/media/base/decoder_buffer.h b/media/base/decoder_buffer.h
index 27de88f..c17aa21 100644
--- a/media/base/decoder_buffer.h
+++ b/media/base/decoder_buffer.h
@@ -14,6 +14,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
+#include "media/base/buffers.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/media_export.h"
 
@@ -77,6 +78,9 @@ class MEDIA_EXPORT DecoderBuffer
 
   void set_duration(base::TimeDelta duration) {
     DCHECK(!end_of_stream());
+    DCHECK(duration == kNoTimestamp() ||
+           (duration >= base::TimeDelta() && duration != kInfiniteDuration()))
+        << duration.InSecondsF();
     duration_ = duration;
   }
 
diff --git a/media/base/stream_parser_buffer.cc b/media/base/stream_parser_buffer.cc
index e9d6427..ae82659 100644
--- a/media/base/stream_parser_buffer.cc
+++ b/media/base/stream_parser_buffer.cc
@@ -106,6 +106,11 @@ void StreamParserBuffer::SetConfigId(int config_id) {
 void StreamParserBuffer::ConvertToSpliceBuffer(
     const BufferQueue& pre_splice_buffers) {
   DCHECK(splice_buffers_.empty());
+  DCHECK(duration() > base::TimeDelta())
+      << "Only buffers with a valid duration can convert to a splice buffer."
+      << " pts " << timestamp().InSecondsF()
+      << " dts " << GetDecodeTimestamp().InSecondsF()
+      << " dur " << duration().InSecondsF();
   DCHECK(!end_of_stream());
 
   // Make a copy of this first, before making any changes.
@@ -139,6 +144,8 @@ void StreamParserBuffer::ConvertToSpliceBuffer(
 
   // The splice duration is the duration of all buffers before the splice plus
   // the highest ending timestamp after the splice point.
+  DCHECK(overlapping_buffer->duration() > base::TimeDelta());
+  DCHECK(pre_splice_buffers.back()->duration() > base::TimeDelta());
   set_duration(
       std::max(overlapping_buffer->timestamp() + overlapping_buffer->duration(),
                pre_splice_buffers.back()->timestamp() +
diff --git a/media/filters/source_buffer_stream.cc b/media/filters/source_buffer_stream.cc
index f72b00a..8bc65854 100644
--- a/media/filters/source_buffer_stream.cc
+++ b/media/filters/source_buffer_stream.cc
@@ -717,6 +717,11 @@ bool SourceBufferStream::IsMonotonicallyIncreasing(
     base::TimeDelta current_timestamp = (*itr)->GetDecodeTimestamp();
     bool current_is_keyframe = (*itr)->IsKeyframe();
     DCHECK(current_timestamp != kNoTimestamp());
+    DCHECK((*itr)->duration() >= base::TimeDelta())
+        << "Packet with invalid duration."
+        << " pts " << (*itr)->timestamp().InSecondsF()
+        << " dts " << (*itr)->GetDecodeTimestamp().InSecondsF()
+        << " dur " << (*itr)->duration().InSecondsF();
 
     if (prev_timestamp != kNoTimestamp()) {
       if (current_timestamp < prev_timestamp) {
diff --git a/media/filters/source_buffer_stream_unittest.cc b/media/filters/source_buffer_stream_unittest.cc
index 50efdac..f4c2821 100644
--- a/media/filters/source_buffer_stream_unittest.cc
+++ b/media/filters/source_buffer_stream_unittest.cc
@@ -31,8 +31,7 @@ static const int kDataSize = 1;
 
 class SourceBufferStreamTest : public testing::Test {
  protected:
-  SourceBufferStreamTest()
-      : accurate_durations_(false) {
+  SourceBufferStreamTest() {
     video_config_ = TestVideoConfig::Normal();
     SetStreamInfo(kDefaultFramesPerSecond, kDefaultKeyframesPerSecond);
     stream_.reset(new SourceBufferStream(video_config_, log_cb(), true));
@@ -57,7 +56,6 @@ class SourceBufferStreamTest : public testing::Test {
 
   void SetAudioStream() {
     video_config_ = TestVideoConfig::Invalid();
-    accurate_durations_ = true;
     audio_config_.Initialize(kCodecVorbis,
                              kSampleFormatPlanarF32,
                              CHANNEL_LAYOUT_STEREO,
@@ -278,8 +276,7 @@ class SourceBufferStreamTest : public testing::Test {
             break;
         }
 
-        if (timestamps[i] == "C")
-          EXPECT_EQ(SourceBufferStream::kConfigChange, status);
+        EXPECT_EQ("C", timestamps[i]);
 
         ss << "C";
         continue;
@@ -407,8 +404,7 @@ class SourceBufferStreamTest : public testing::Test {
         presentation_timestamp = timestamp - frame_duration_;
       }
       buffer->set_timestamp(presentation_timestamp);
-      if (accurate_durations_)
-        buffer->set_duration(frame_duration_);
+      buffer->set_duration(frame_duration_);
 
       queue.push_back(buffer);
     }
@@ -416,14 +412,28 @@ class SourceBufferStreamTest : public testing::Test {
       EXPECT_EQ(expect_success, stream_->Append(queue));
   }
 
+  void UpdateLastBufferDuration(base::TimeDelta current_dts,
+                                BufferQueue* buffers) {
+    if (buffers->empty() || buffers->back()->duration() > base::TimeDelta())
+      return;
+
+    base::TimeDelta last_dts = buffers->back()->GetDecodeTimestamp();
+    DCHECK(current_dts >= last_dts);
+    buffers->back()->set_duration(current_dts - last_dts);
+  }
+
   // StringToBufferQueue() allows for the generation of StreamParserBuffers from
   // coded strings of timestamps separated by spaces.  Supported syntax:
   //
-  // ##:
+  // ## or ##Dyy:
   // Generates a StreamParserBuffer with decode timestamp ##.  E.g., "0 1 2 3".
+  // The form with the 'D' sets the decode timestamp to ## and the duration to
+  // yy milliseconds.
   //
-  // ##K:
+  // ##K or ##DyyK:
   // Indicates the buffer with timestamp ## reflects a keyframe.  E.g., "0K 1".
+  // The form with the 'D' indicates a buffer with timestamp ##, duration yy,
+  // and is marked as a keyframe.
   //
   // S(a# ... y# z#)
   // Indicates a splice frame buffer should be created with timestamp z#.  The
@@ -479,7 +489,15 @@ class SourceBufferStreamTest : public testing::Test {
         timestamps[i] = timestamps[i].substr(0, timestamps[i].length() - 1);
       }
 
-      int time_in_ms;
+      int time_in_ms = 0;
+      int duration_in_ms = 0;
+      size_t duration_pos = timestamps[i].find('D');
+      if (duration_pos != std::string::npos) {
+        CHECK(base::StringToInt(timestamps[i].substr(duration_pos + 1),
+                                &duration_in_ms));
+        timestamps[i] = timestamps[i].substr(0, duration_pos);
+      }
+
       CHECK(base::StringToInt(timestamps[i], &time_in_ms));
 
       // Create buffer. Buffer type and track ID are meaningless to these tests.
@@ -489,8 +507,8 @@ class SourceBufferStreamTest : public testing::Test {
       base::TimeDelta timestamp =
           base::TimeDelta::FromMilliseconds(time_in_ms);
       buffer->set_timestamp(timestamp);
-      if (accurate_durations_)
-        buffer->set_duration(frame_duration_);
+      if (duration_in_ms)
+        buffer->set_duration(base::TimeDelta::FromMilliseconds(duration_in_ms));
       buffer->SetDecodeTimestamp(timestamp);
 
       // Simulate preroll buffers by just generating another buffer and sticking
@@ -511,6 +529,8 @@ class SourceBufferStreamTest : public testing::Test {
               pre_splice_buffers.back()->GetDecodeTimestamp().InMicroseconds());
         }
         buffer->SetConfigId(splice_config_id);
+        UpdateLastBufferDuration(buffer->GetDecodeTimestamp(),
+                                 &pre_splice_buffers);
         pre_splice_buffers.push_back(buffer);
         continue;
       }
@@ -523,8 +543,18 @@ class SourceBufferStreamTest : public testing::Test {
         pre_splice_buffers.clear();
       }
 
+      UpdateLastBufferDuration(buffer->GetDecodeTimestamp(), &buffers);
       buffers.push_back(buffer);
     }
+
+    // If the last buffer doesn't have a duration, assume it is the
+    // same as the second to last buffer.
+    if (buffers.size() >= 2 &&
+        buffers.back()->duration() <= base::TimeDelta()) {
+      buffers.back()->set_duration(
+          buffers[buffers.size() - 2]->duration());
+    }
+
     return buffers;
   }
 
@@ -565,10 +595,6 @@ class SourceBufferStreamTest : public testing::Test {
   int frames_per_second_;
   int keyframes_per_second_;
   base::TimeDelta frame_duration_;
-  // TODO(dalecurtis): It's silly to have this, all tests should use accurate
-  // durations instead.  However, currently all tests are written with an
-  // expectation of 0 duration, so it's an involved change.
-  bool accurate_durations_;
   DISALLOW_COPY_AND_ASSIGN(SourceBufferStreamTest);
 };
 
@@ -691,7 +717,7 @@ TEST_F(SourceBufferStreamTest,
   // Completely overlap the old buffers, with a segment that starts
   // after the old segment start timestamp, but before the timestamp
   // of the first buffer in the segment.
-  NewSegmentAppend("20K 50K 80K 110K");
+  NewSegmentAppend("20K 50K 80K 110D10K");
 
   // Verify that the buffered ranges are updated properly and we don't crash.
   CheckExpectedRangesByTimestamp("{ [20,150) }");
@@ -779,7 +805,7 @@ TEST_F(SourceBufferStreamTest, End_Overlap_SingleBuffer) {
   NewSegmentAppend("0K 30 60 90 120K 150");
   CheckExpectedRangesByTimestamp("{ [0,180) }");
 
-  NewSegmentAppend("0K");
+  NewSegmentAppend("0D30K");
   CheckExpectedRangesByTimestamp("{ [0,30) [120,180) }");
 
   CheckExpectedBuffers("0K");
@@ -1548,8 +1574,8 @@ TEST_F(SourceBufferStreamTest, Overlap_OneByOne_DeleteGroup) {
   // Seek to 130ms.
   SeekToTimestamp(base::TimeDelta::FromMilliseconds(130));
 
-  // Overlap with a new segment from 0 to 120ms.
-  NewSegmentAppendOneByOne("0K 120");
+  // Overlap with a new segment from 0 to 130ms.
+  NewSegmentAppendOneByOne("0K 120D10");
 
   // Next buffer should still be 130ms.
   CheckExpectedBuffers("130K");
@@ -1580,21 +1606,21 @@ TEST_F(SourceBufferStreamTest, Overlap_OneByOne_BetweenMediaSegments) {
 // new  : 0K   30   60   90   120K
 // after: 0K   30   60   90  *120K*   130K
 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer) {
-  NewSegmentAppendOneByOne("10K 40 70 100K 125 130K");
+  NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K");
   CheckExpectedRangesByTimestamp("{ [10,160) }");
 
   // Seek to 70ms.
   SeekToTimestamp(base::TimeDelta::FromMilliseconds(70));
   CheckExpectedBuffers("10K 40");
 
-  // Overlap with a new segment from 0 to 120ms.
-  NewSegmentAppendOneByOne("0K 30 60 90 120K");
+  // Overlap with a new segment from 0 to 130ms.
+  NewSegmentAppendOneByOne("0K 30 60 90 120D10K");
   CheckExpectedRangesByTimestamp("{ [0,160) }");
 
-  // Should return frames 70ms and 100ms from the track buffer, then switch
+  // Should return frame 70ms from the track buffer, then switch
   // to the new data at 120K, then switch back to the old data at 130K. The
   // frame at 125ms that depended on keyframe 100ms should have been deleted.
-  CheckExpectedBuffers("70 100K 120K 130K");
+  CheckExpectedBuffers("70 120K 130K");
 
   // Check the final result: should not include data from the track buffer.
   SeekToTimestamp(base::TimeDelta::FromMilliseconds(0));
@@ -1606,11 +1632,11 @@ TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer) {
 // old  :   10K  40  *70*  100K  125  130K
 // new  : 0K   30   60   90   120K
 // after: 0K   30   60   90  *120K*   130K
-// track:             70   100K
+// track:             70
 // new  :                     110K    130
 // after: 0K   30   60   90  *110K*   130
 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer2) {
-  NewSegmentAppendOneByOne("10K 40 70 100K 125 130K");
+  NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K");
   CheckExpectedRangesByTimestamp("{ [10,160) }");
 
   // Seek to 70ms.
@@ -1619,15 +1645,15 @@ TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer2) {
 
   // Overlap with a new segment from 0 to 120ms; 70ms and 100ms go in track
   // buffer.
-  NewSegmentAppendOneByOne("0K 30 60 90 120K");
+  NewSegmentAppendOneByOne("0K 30 60 90 120D10K");
   CheckExpectedRangesByTimestamp("{ [0,160) }");
 
   // Now overlap the keyframe at 120ms.
   NewSegmentAppendOneByOne("110K 130");
 
-  // Should expect buffers 70ms and 100ms from the track buffer. Then it should
+  // Should return frame 70ms from the track buffer. Then it should
   // return the keyframe after the track buffer, which is at 110ms.
-  CheckExpectedBuffers("70 100K 110K 130");
+  CheckExpectedBuffers("70 110K 130");
 }
 
 // Overlap the next keyframe after the end of the track buffer without a
@@ -1635,33 +1661,32 @@ TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer2) {
 // old  :   10K  40  *70*  100K  125  130K
 // new  : 0K   30   60   90   120K
 // after: 0K   30   60   90  *120K*   130K
-// track:             70   100K
+// track:             70
 // new  :        50K   80   110          140
 // after: 0K   30   50K   80   110   140 * (waiting for keyframe)
-// track:               70   100K   120K   130K
+// track:             70
 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer3) {
-  NewSegmentAppendOneByOne("10K 40 70 100K 125 130K");
+  NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K");
   CheckExpectedRangesByTimestamp("{ [10,160) }");
 
   // Seek to 70ms.
   SeekToTimestamp(base::TimeDelta::FromMilliseconds(70));
   CheckExpectedBuffers("10K 40");
 
-  // Overlap with a new segment from 0 to 120ms; 70ms and 100ms go in track
-  // buffer.
-  NewSegmentAppendOneByOne("0K 30 60 90 120K");
+  // Overlap with a new segment from 0 to 120ms; 70ms goes in track buffer.
+  NewSegmentAppendOneByOne("0K 30 60 90 120D10K");
   CheckExpectedRangesByTimestamp("{ [0,160) }");
 
-  // Now overlap the keyframe at 120ms. There's no keyframe after 70ms, so 120ms
-  // and 130ms go into the track buffer.
+  // Now overlap the keyframe at 120ms and 130ms.
   NewSegmentAppendOneByOne("50K 80 110 140");
+  CheckExpectedRangesByTimestamp("{ [0,170) }");
 
   // Should have all the buffers from the track buffer, then stall.
-  CheckExpectedBuffers("70 100K 120K 130K");
+  CheckExpectedBuffers("70");
   CheckNoNextBuffer();
 
   // Appending a keyframe should fulfill the read.
-  AppendBuffersOneByOne("150K");
+  AppendBuffersOneByOne("150D30K");
   CheckExpectedBuffers("150K");
   CheckNoNextBuffer();
 }
@@ -1671,12 +1696,12 @@ TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer3) {
 // old  :   10K  40  *70*  100K  125  130K
 // new  : 0K   30   60   90   120K
 // after: 0K   30   60   90  *120K*   130K
-// track:             70   100K
+// track:             70
 // new  :              80K  110          140
 // after: 0K   30   60   *80K*  110   140
 // track:               70
 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer4) {
-  NewSegmentAppendOneByOne("10K 40 70 100K 125 130K");
+  NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K");
   CheckExpectedRangesByTimestamp("{ [10,160) }");
 
   // Seek to 70ms.
@@ -1685,7 +1710,7 @@ TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer4) {
 
   // Overlap with a new segment from 0 to 120ms; 70ms and 100ms go in track
   // buffer.
-  NewSegmentAppendOneByOne("0K 30 60 90 120K");
+  NewSegmentAppendOneByOne("0K 30 60 90 120D10K");
   CheckExpectedRangesByTimestamp("{ [0,160) }");
 
   // Now append a keyframe at 80ms.
@@ -1701,7 +1726,7 @@ TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer4) {
 // old  :   10K  40  *70*  100K
 // new  : 0K   30   60   90   120
 // after: 0K   30   60   90   120 * (waiting for keyframe)
-// track:             70   100K
+// track:             70
 // new  :              80K  110          140
 // after: 0K   30   60   *80K*  110   140
 // track:               70
@@ -1713,13 +1738,12 @@ TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer5) {
   SeekToTimestamp(base::TimeDelta::FromMilliseconds(70));
   CheckExpectedBuffers("10K 40");
 
-  // Overlap with a new segment from 0 to 120ms; 70ms and 100ms go in track
+  // Overlap with a new segment from 0 to 120ms; 70ms goes in track
   // buffer.
   NewSegmentAppendOneByOne("0K 30 60 90 120");
   CheckExpectedRangesByTimestamp("{ [0,150) }");
 
-  // Now append a keyframe at 80ms. The buffer at 100ms should be deleted from
-  // the track buffer.
+  // Now append a keyframe at 80ms.
   NewSegmentAppendOneByOne("80K 110 140");
 
   CheckExpectedBuffers("70 80K 110 140");
@@ -1731,13 +1755,13 @@ TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer5) {
 // old  :   10K  40  *70*  100K  125  130K ... 200K 230
 // new  : 0K   30   60   90   120K
 // after: 0K   30   60   90  *120K*   130K ... 200K 230
-// track:             70   100K
+// track:             70
 // old  : 0K   30   60   90  *120K*   130K ... 200K 230
 // new  :                                               260K 290
 // after: 0K   30   60   90  *120K*   130K ... 200K 230 260K 290
-// track:             70   100K
+// track:             70
 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer6) {
-  NewSegmentAppendOneByOne("10K 40 70 100K 125 130K");
+  NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K");
   NewSegmentAppendOneByOne("200K 230");
   CheckExpectedRangesByTimestamp("{ [10,160) [200,260) }");
 
@@ -1746,7 +1770,7 @@ TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer6) {
   CheckExpectedBuffers("10K 40");
 
   // Overlap with a new segment from 0 to 120ms.
-  NewSegmentAppendOneByOne("0K 30 60 90 120K");
+  NewSegmentAppendOneByOne("0K 30 60 90 120D10K");
   CheckExpectedRangesByTimestamp("{ [0,160) [200,260) }");
 
   // Verify that 70 gets read out of the track buffer.
@@ -1756,7 +1780,7 @@ TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer6) {
   NewSegmentAppendOneByOne("260K 290");
   CheckExpectedRangesByTimestamp("{ [0,160) [200,320) }");
 
-  CheckExpectedBuffers("100K 120K 130K");
+  CheckExpectedBuffers("120K 130K");
   CheckNoNextBuffer();
 
   // Check the final result: should not include data from the track buffer.
@@ -2122,7 +2146,7 @@ TEST_F(SourceBufferStreamTest, GetNextBuffer_ExhaustThenStartOverlap2) {
   CheckNoNextBuffer();
 
   // Append a keyframe with the same timestamp as the last buffer output.
-  NewSegmentAppend("120K");
+  NewSegmentAppend("120D30K");
   CheckNoNextBuffer();
 
   // Append the rest of the segment and make sure that buffers are returned
@@ -2550,7 +2574,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP) {
 
   // Make sure you can continue appending data to this GOP; again, GC should not
   // wipe out anything.
-  AppendBuffers("120");
+  AppendBuffers("120D30");
   CheckExpectedRangesByTimestamp("{ [0,150) }");
 
   // Set memory limit to 100 and append a 2nd range after this without
@@ -2572,7 +2596,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP) {
   CheckExpectedRangesByTimestamp("{ [290,380) [500,620) }");
 
   // Continue appending to this GOP after GC.
-  AppendBuffers("620");
+  AppendBuffers("620D30");
   CheckExpectedRangesByTimestamp("{ [290,380) [500,650) }");
 }
 
@@ -2591,7 +2615,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Middle) {
   // This whole GOP should be saved, and should be able to continue appending
   // data to it.
   CheckExpectedRangesByTimestamp("{ [80,170) }");
-  AppendBuffers("170");
+  AppendBuffers("170D30");
   CheckExpectedRangesByTimestamp("{ [80,200) }");
 
   // Set memory limit to 100 and append a 2nd range after this without
@@ -2614,7 +2638,7 @@ TEST_F(SourceBufferStreamTest, GarbageCollection_SaveAppendGOP_Middle) {
   CheckExpectedRangesByTimestamp("{ [80,200) [500,620) }");
 
   // Continue appending to this GOP after GC.
-  AppendBuffers("620");
+  AppendBuffers("620D30");
   CheckExpectedRangesByTimestamp("{ [80,200) [500,650) }");
 }
 
@@ -3629,7 +3653,7 @@ TEST_F(SourceBufferStreamTest, Text_CompleteOverlap) {
   CheckExpectedRangesByTimestamp("{ [3000,4500) }");
   NewSegmentAppend("0K 501K 1001K 1501K 2001K 2501K "
                    "3001K 3501K 4001K 4501K 5001K");
-  CheckExpectedRangesByTimestamp("{ [0,5502) }");
+  CheckExpectedRangesByTimestamp("{ [0,5501) }");
 
   Seek(0);
   CheckExpectedBuffers("0K 501K 1001K 1501K 2001K 2501K "
@@ -3641,7 +3665,7 @@ TEST_F(SourceBufferStreamTest, Text_OverlapAfter) {
   NewSegmentAppend("0K 500K 1000K 1500K 2000K");
   CheckExpectedRangesByTimestamp("{ [0,2500) }");
   NewSegmentAppend("1499K 2001K 2501K 3001K");
-  CheckExpectedRangesByTimestamp("{ [0,3503) }");
+  CheckExpectedRangesByTimestamp("{ [0,3501) }");
 
   Seek(0);
   CheckExpectedBuffers("0K 500K 1000K 1499K 2001K 2501K 3001K");
@@ -3652,22 +3676,22 @@ TEST_F(SourceBufferStreamTest, Text_OverlapBefore) {
   NewSegmentAppend("1500K 2000K 2500K 3000K 3500K");
   CheckExpectedRangesByTimestamp("{ [1500,4000) }");
   NewSegmentAppend("0K 501K 1001K 1501K 2001K");
-  CheckExpectedRangesByTimestamp("{ [0,4001) }");
+  CheckExpectedRangesByTimestamp("{ [0,4000) }");
 
   Seek(0);
-  CheckExpectedBuffers("0K 501K 1001K 1501K 2001K 2500K 3000K 3500K");
+  CheckExpectedBuffers("0K 501K 1001K 1501K 2001K 3000K 3500K");
 }
 
 TEST_F(SourceBufferStreamTest, SpliceFrame_Basic) {
   Seek(0);
-  NewSegmentAppend("0K S(3K 6 9 10) 15 20 S(25K 30 35) 40");
+  NewSegmentAppend("0K S(3K 6 9D3 10D5) 15 20 S(25K 30D5 35D5) 40");
   CheckExpectedBuffers("0K 3K 6 9 C 10 15 20 25K 30 C 35 40");
   CheckNoNextBuffer();
 }
 
 TEST_F(SourceBufferStreamTest, SpliceFrame_SeekClearsSplice) {
   Seek(0);
-  NewSegmentAppend("0K S(3K 6 9 10) 15K 20");
+  NewSegmentAppend("0K S(3K 6 9D3 10D5) 15K 20");
   CheckExpectedBuffers("0K 3K 6");
 
   SeekToTimestamp(base::TimeDelta::FromMilliseconds(15));
@@ -3677,7 +3701,7 @@ TEST_F(SourceBufferStreamTest, SpliceFrame_SeekClearsSplice) {
 
 TEST_F(SourceBufferStreamTest, SpliceFrame_SeekClearsSpliceFromTrackBuffer) {
   Seek(0);
-  NewSegmentAppend("0K 2K S(3K 6 9 10) 15K 20");
+  NewSegmentAppend("0K 2K S(3K 6 9D3 10D5) 15K 20");
   CheckExpectedBuffers("0K 2K");
 
   // Overlap the existing segment.
@@ -3699,7 +3723,7 @@ TEST_F(SourceBufferStreamTest, SpliceFrame_ConfigChangeWithinSplice) {
 
   Seek(0);
   CheckVideoConfig(video_config_);
-  NewSegmentAppend("0K S(3K 6C 9 10) 15");
+  NewSegmentAppend("0K S(3K 6C 9D3 10D5) 15");
 
   CheckExpectedBuffers("0K 3K C");
   CheckVideoConfig(new_config);
@@ -3712,7 +3736,7 @@ TEST_F(SourceBufferStreamTest, SpliceFrame_ConfigChangeWithinSplice) {
 
 TEST_F(SourceBufferStreamTest, SpliceFrame_BasicFromTrackBuffer) {
   Seek(0);
-  NewSegmentAppend("0K 5K S(8K 9 10) 20");
+  NewSegmentAppend("0K 5K S(8K 9D1 10D10) 20");
   CheckExpectedBuffers("0K 5K");
 
   // Overlap the existing segment.
@@ -3732,7 +3756,7 @@ TEST_F(SourceBufferStreamTest,
 
   Seek(0);
   CheckVideoConfig(video_config_);
-  NewSegmentAppend("0K 5K S(7K 8C 9 10) 20");
+  NewSegmentAppend("0K 5K S(7K 8C 9D1 10D10) 20");
   CheckExpectedBuffers("0K 5K");
 
   // Overlap the existing segment.
@@ -3777,7 +3801,7 @@ TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoDoubleSplice) {
   Seek(0);
 
   // Create a splice before the first splice which would include it.
-  NewSegmentAppend("9K");
+  NewSegmentAppend("9D2K");
 
   // A splice on top of a splice should result in a discard of the original
   // splice and no new splice frame being generated.
@@ -3803,7 +3827,7 @@ TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_CorrectMediaSegmentStartTime) {
   CheckExpectedRangesByTimestamp("{ [0,6) }");
   NewSegmentAppend("6K 8K 10K");
   CheckExpectedRangesByTimestamp("{ [0,12) }");
-  NewSegmentAppend("1K 4K");
+  NewSegmentAppend("1K 4D2K");
   CheckExpectedRangesByTimestamp("{ [0,12) }");
   CheckExpectedBuffers("0K 2K 4K C 1K 4K 6K 8K 10K");
   CheckNoNextBuffer();
@@ -3840,9 +3864,9 @@ TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoTinySplices) {
   // 2ms this results in an overlap of 1ms between the ranges.  A splice frame
   // should not be generated since it requires at least 2 frames, or 2ms in this
   // case, of data to crossfade.
-  NewSegmentAppend("0K");
+  NewSegmentAppend("0D2K");
   CheckExpectedRangesByTimestamp("{ [0,2) }");
-  NewSegmentAppend("1K");
+  NewSegmentAppend("1D2K");
   CheckExpectedRangesByTimestamp("{ [0,3) }");
   CheckExpectedBuffers("0K 1K");
   CheckNoNextBuffer();