MSE: Warn when keyframe after track_buffer is significantly in future

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 <stdint.h>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "media/base/data_buffer.h"
 #include "media/base/media_log.h"
+#include "media/base/mock_media_log.h"
 #include "media/base/test_helpers.h"
 #include "media/base/text_track_config.h"
 #include "media/filters/webvtt_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using ::testing::HasSubstr;
+using ::testing::InSequence;
+using ::testing::StrictMock;
+
+// Helper macros to reduce boilerplate when verifying media log entries.
+#define EXPECT_MEDIA_LOG_STRING(x) \
+  EXPECT_CALL(*media_log_, DoAddEventLogString((x)))
+#define CONTAINS_STRING(arg, x) (std::string::npos != (arg).find(x))
+
 namespace media {
 
 typedef StreamParser::BufferQueue BufferQueue;
 
 static const int kDefaultFramesPerSecond = 30;
 static const int kDefaultKeyframesPerSecond = 6;
 static const uint8 kDataA = 0x11;
 static const uint8 kDataB = 0x33;
 static const int kDataSize = 1;
 
+// Matchers for verifying common media log entry strings.
+MATCHER(ContainsMissingKeyframeLog, "") {
+  return CONTAINS_STRING(arg,
+                         "Media segment did not begin with key frame. Support "
+                         "for such segments will be available in a future "
+                         "version. Please see https://crbug.com/229412.");
+}
+
+MATCHER(ContainsSameTimestampAt30MillisecondsLog, "") {
+  return CONTAINS_STRING(arg,
+                         "Unexpected combination of buffers with the same "
+                         "timestamp detected at 0.03");
+}
+
+MATCHER_P(ContainsTrackBufferExhaustionSkipLog, skip_milliseconds, "") {
+  return CONTAINS_STRING(arg,
+                         "Media append that overlapped current playback "
+                         "position caused time gap in playing VIDEO stream "
+                         "because the next keyframe is " +
+                             base::IntToString(skip_milliseconds) +
+                             "ms beyond last overlapped frame. Media may "
+                             "appear temporarily frozen.");
+}
+
+MATCHER_P2(ContainsGeneratedSpliceLog,
+           duration_microseconds,
+           time_microseconds,
+           "") {
+  return CONTAINS_STRING(arg, "Generated splice of overlap duration " +
+                                  base::IntToString(duration_microseconds) +
+                                  "us into new buffer at " +
+                                  base::IntToString(time_microseconds) + "us.");
+}
+
 class SourceBufferStreamTest : public testing::Test {
  protected:
-  SourceBufferStreamTest() {
+  SourceBufferStreamTest() : media_log_(new StrictMock<MockMediaLog>()) {
     video_config_ = TestVideoConfig::Normal();
     SetStreamInfo(kDefaultFramesPerSecond, kDefaultKeyframesPerSecond);
-    stream_.reset(new SourceBufferStream(video_config_, new MediaLog(), true));
+    stream_.reset(new SourceBufferStream(video_config_, media_log_, true));
   }
 
   void SetMemoryLimit(size_t buffers_of_data) {
     stream_->set_memory_limit(buffers_of_data * kDataSize);
   }
 
   void SetStreamInfo(int frames_per_second, int keyframes_per_second) {
     frames_per_second_ = frames_per_second;
     keyframes_per_second_ = keyframes_per_second;
     frame_duration_ = ConvertToFrameDuration(frames_per_second);
   }
 
   void SetTextStream() {
     video_config_ = TestVideoConfig::Invalid();
     TextTrackConfig config(kTextSubtitles, "", "", "");
-    stream_.reset(new SourceBufferStream(config, new MediaLog(), true));
+    stream_.reset(new SourceBufferStream(config, media_log_, true));
     SetStreamInfo(2, 2);
   }
 
   void SetAudioStream() {
     video_config_ = TestVideoConfig::Invalid();
     audio_config_.Initialize(kCodecVorbis,
                              kSampleFormatPlanarF32,
                              CHANNEL_LAYOUT_STEREO,
                              1000,
                              NULL,
                              0,
                              false,
                              false,
                              base::TimeDelta(),
                              0);
-    stream_.reset(new SourceBufferStream(audio_config_, new MediaLog(), true));
+    stream_.reset(new SourceBufferStream(audio_config_, media_log_, true));
 
     // Equivalent to 2ms per frame.
     SetStreamInfo(500, 500);
   }
 
   void NewSegmentAppend(int starting_position, int number_of_buffers) {
     AppendBuffers(starting_position, number_of_buffers, true,
                   base::TimeDelta(), true, &kDataA, kDataSize);
   }
 
@@ skipping 287 matching lines @@
     EXPECT_TRUE(actual.Matches(config))
         << "Expected: " << config.AsHumanReadableString()
         << "\nActual: " << actual.AsHumanReadableString();
   }
 
   base::TimeDelta frame_duration() const { return frame_duration_; }
 
   scoped_ptr<SourceBufferStream> stream_;
   VideoDecoderConfig video_config_;
   AudioDecoderConfig audio_config_;
+  scoped_refptr<StrictMock<MockMediaLog>> media_log_;
 
  private:
   base::TimeDelta ConvertToFrameDuration(int frames_per_second) {
     return base::TimeDelta::FromMicroseconds(
         base::Time::kMicrosecondsPerSecond / frames_per_second);
   }
 
   void AppendBuffers(int starting_position,
                      int number_of_buffers,
                      bool begin_media_segment,
@@ skipping 331 matching lines @@
   NewSegmentAppend(10, 5);
 
   // Check expected range.
   CheckExpectedRanges("{ [0,25) }");
   // Check buffers in range.
   Seek(0);
   CheckExpectedBuffers(0, 25);
 }
 
 TEST_F(SourceBufferStreamTest, Append_DoesNotBeginWithKeyframe) {
+  EXPECT_MEDIA_LOG_STRING(ContainsMissingKeyframeLog()).Times(2);
+
   // Append fails because the range doesn't begin with a keyframe.
   NewSegmentAppend_ExpectFailure(3, 2);
 
   // Append 10 buffers at positions 5 through 14.
   NewSegmentAppend(5, 10);
 
   // Check expected range.
   CheckExpectedRanges("{ [5,14) }");
   // Check buffers in range.
   Seek(5);
   CheckExpectedBuffers(5, 14);
 
   // Append fails because the range doesn't begin with a keyframe.
   NewSegmentAppend_ExpectFailure(17, 3);
 
   CheckExpectedRanges("{ [5,14) }");
   Seek(5);
   CheckExpectedBuffers(5, 14);
 }
 
 TEST_F(SourceBufferStreamTest, Append_DoesNotBeginWithKeyframe_Adjacent) {
+  EXPECT_MEDIA_LOG_STRING(ContainsMissingKeyframeLog());
+
   // Append 8 buffers at positions 0 through 7.
   NewSegmentAppend(0, 8);
 
   // Now start a new media segment at position 8. Append should fail because
   // the media segment does not begin with a keyframe.
   NewSegmentAppend_ExpectFailure(8, 2);
 
   // Check expected range.
   CheckExpectedRanges("{ [0,7) }");
   // Check buffers in range.
@@ skipping 645 matching lines @@
 // range, and there is no keyframe after the end of the new buffers, then the
 // range gets split.
 // 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*|
 // new  :            B b b b b B b b b b B
 // after:           |B b b b b B b b b b B|
 // new  :  A a a a a A
 // after: |A a a a a A|       |B b b b b B|
 // track:                                 |a|
 TEST_F(SourceBufferStreamTest, End_Overlap_Selected_NoKeyframeAfterNew2) {
+  EXPECT_MEDIA_LOG_STRING(ContainsTrackBufferExhaustionSkipLog(133));
+
   // Append 7 buffers at positions 10 through 16.
   NewSegmentAppend(10, 7, &kDataA);
 
   // Seek to position 15, then move to position 16.
   Seek(15);
   CheckExpectedBuffers(15, 15, &kDataA);
 
   // Now append 11 buffers at positions 5 through 15.
   NewSegmentAppend(5, 11, &kDataB);
   CheckExpectedRanges("{ [5,15) }");
@@ skipping 244 matching lines @@
   // Check the final buffers is correct; the keyframe at 110ms should be
   // deleted.
   SeekToTimestampMs(0);
   CheckExpectedBuffers("0K 30 60 90 120K 150 180 210");
 }
 
 // old  :   10K  40  *70*  100K  125  130K
 // new  : 0K   30   60   90   120K
 // after: 0K   30   60   90  *120K*   130K
 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer) {
+  EXPECT_MEDIA_LOG_STRING(ContainsTrackBufferExhaustionSkipLog(50));
+
   NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K");
   CheckExpectedRangesByTimestamp("{ [10,160) }");
 
   // Seek to 70ms.
   SeekToTimestampMs(70);
   CheckExpectedBuffers("10K 40");
 
   // Overlap with a new segment from 0 to 130ms.
   NewSegmentAppendOneByOne("0K 30 60 90 120D10K");
   CheckExpectedRangesByTimestamp("{ [0,160) }");
@@ skipping 10 matching lines @@
 
 // Overlap the next keyframe after the end of the track buffer with a new
 // keyframe.
 // old  :   10K  40  *70*  100K  125  130K
 // new  : 0K   30   60   90   120K
 // after: 0K   30   60   90  *120K*   130K
 // track:             70
 // new  :                     110K    130
 // after: 0K   30   60   90  *110K*   130
 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer2) {
+  EXPECT_MEDIA_LOG_STRING(ContainsTrackBufferExhaustionSkipLog(40));
+
   NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K");
   CheckExpectedRangesByTimestamp("{ [10,160) }");
 
   // Seek to 70ms.
   SeekToTimestampMs(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 120D10K");
@@ skipping 10 matching lines @@
 // Overlap the next keyframe after the end of the track buffer without a
 // new keyframe.
 // old  :   10K  40  *70*  100K  125  130K
 // new  : 0K   30   60   90   120K
 // after: 0K   30   60   90  *120K*   130K
 // track:             70
 // new  :        50K   80   110          140
 // after: 0K   30   50K   80   110   140 * (waiting for keyframe)
 // track:             70
 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer3) {
+  EXPECT_MEDIA_LOG_STRING(ContainsTrackBufferExhaustionSkipLog(80));
+
   NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K");
   CheckExpectedRangesByTimestamp("{ [10,160) }");
 
   // Seek to 70ms.
   SeekToTimestampMs(70);
   CheckExpectedBuffers("10K 40");
 
   // Overlap with a new segment from 0 to 120ms; 70ms goes in track buffer.
   NewSegmentAppendOneByOne("0K 30 60 90 120D10K");
   CheckExpectedRangesByTimestamp("{ [0,160) }");
@@ skipping 75 matching lines @@
 // the track buffer doesn't affect the selected range or track buffer state.
 // 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
 // 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
 TEST_F(SourceBufferStreamTest, Overlap_OneByOne_TrackBuffer6) {
+  EXPECT_MEDIA_LOG_STRING(ContainsTrackBufferExhaustionSkipLog(50));
+
   NewSegmentAppendOneByOne("10K 40 70 100K 125 130D30K");
   NewSegmentAppendOneByOne("200K 230");
   CheckExpectedRangesByTimestamp("{ [10,160) [200,260) }");
 
   // Seek to 70ms.
   SeekToTimestampMs(70);
   CheckExpectedBuffers("10K 40");
 
   // Overlap with a new segment from 0 to 120ms.
   NewSegmentAppendOneByOne("0K 30 60 90 120D10K");
@@ skipping 752 matching lines @@
   CheckExpectedRanges("{ [5,9) [15,19) [30,34) }");
 
   // Now fulfill the seek at position 10. This will make GC delete the data
   // before position 10 to keep it within cap.
   NewSegmentAppend(10, 5, &kDataA);
   CheckExpectedRanges("{ [10,19) [30,34) }");
   CheckExpectedBuffers(10, 19, &kDataA);
 }
 
 TEST_F(SourceBufferStreamTest, GarbageCollection_TrackBuffer) {
+  EXPECT_MEDIA_LOG_STRING(ContainsTrackBufferExhaustionSkipLog(99));
+
   // Set memory limit to 3 buffers.
   SetMemoryLimit(3);
 
   // Seek to position 15.
   Seek(15);
 
   // Append 18 buffers at positions 0 through 17.
   NewSegmentAppend(0, 18, &kDataA);
 
   // Should leave GOP containing seek position.
@@ skipping 729 matching lines @@
 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_TwoAppends) {
   Seek(0);
   NewSegmentAppend("0K 30");
   AppendBuffers("30 60 90 120K 150");
   CheckExpectedBuffers("0K 30 30 60 90 120K 150");
 }
 
 // Verify that a non-keyframe followed by a keyframe with the same timestamp
 // is not allowed.
 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_Invalid_1) {
+  EXPECT_MEDIA_LOG_STRING(ContainsSameTimestampAt30MillisecondsLog());
+
   Seek(0);
   NewSegmentAppend("0K 30");
   AppendBuffers_ExpectFailure("30K 60");
 }
 
 TEST_F(SourceBufferStreamTest, SameTimestamp_Video_Invalid_2) {
+  EXPECT_MEDIA_LOG_STRING(ContainsSameTimestampAt30MillisecondsLog());
+
   Seek(0);
   NewSegmentAppend_ExpectFailure("0K 30 30K 60");
 }
 
 // Verify that a keyframe followed by a non-keyframe with the same timestamp
 // is allowed.
 TEST_F(SourceBufferStreamTest, SameTimestamp_VideoKeyFrame_TwoAppends) {
   Seek(0);
   NewSegmentAppend("0K 30K");
   AppendBuffers("30 60");
@@ skipping 30 matching lines @@
   Seek(0);
   CheckExpectedBuffers("0K 20 40 60 80 90 90 110K 150");
   CheckNoNextBuffer();
   CheckExpectedRangesByTimestamp("{ [0,190) }");
 }
 
 // Test all the valid same timestamp cases for audio.
 TEST_F(SourceBufferStreamTest, SameTimestamp_Audio) {
   AudioDecoderConfig config(kCodecMP3, kSampleFormatF32, CHANNEL_LAYOUT_STEREO,
                             44100, NULL, 0, false);
-  stream_.reset(new SourceBufferStream(config, new MediaLog(), true));
+  stream_.reset(new SourceBufferStream(config, media_log_, true));
   Seek(0);
   NewSegmentAppend("0K 0K 30K 30 60 60");
   CheckExpectedBuffers("0K 0K 30K 30 60 60");
 }
 
 TEST_F(SourceBufferStreamTest, SameTimestamp_Audio_Invalid_1) {
+  EXPECT_MEDIA_LOG_STRING(ContainsSameTimestampAt30MillisecondsLog());
+
   AudioDecoderConfig config(kCodecMP3, kSampleFormatF32, CHANNEL_LAYOUT_STEREO,
                             44100, NULL, 0, false);
-  stream_.reset(new SourceBufferStream(config, new MediaLog(), true));
+  stream_.reset(new SourceBufferStream(config, media_log_, true));
   Seek(0);
   NewSegmentAppend_ExpectFailure("0K 30 30K 60");
 }
 
 // If seeking past any existing range and the seek is pending
 // because no data has been provided for that position,
 // the stream position can be considered as the end of stream.
 TEST_F(SourceBufferStreamTest, EndSelected_During_PendingSeek) {
   // Append 15 buffers at positions 0 through 14.
   NewSegmentAppend(0, 15);
@@ skipping 456 matching lines @@
   CheckExpectedBuffers("7K C");
   CheckVideoConfig(new_config);
   CheckExpectedBuffers("8 9 C");
   CheckExpectedBuffers("10 C");
   CheckVideoConfig(video_config_);
   CheckExpectedBuffers("20");
   CheckNoNextBuffer();
 }
 
 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_Basic) {
+  EXPECT_MEDIA_LOG_STRING(ContainsGeneratedSpliceLog(3000, 11000));
+
   SetAudioStream();
   Seek(0);
   NewSegmentAppend("0K 2K 4K 6K 8K 10K 12K");
   NewSegmentAppend("11K 13K 15K 17K");
   CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 12K C 11K 13K 15K 17K");
   CheckNoNextBuffer();
 }
 
 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoExactSplices) {
+  EXPECT_MEDIA_LOG_STRING(
+      HasSubstr("Skipping splice frame generation: first new buffer at 10000us "
+                "begins at or before existing buffer at 10000us."));
+
   SetAudioStream();
   Seek(0);
   NewSegmentAppend("0K 2K 4K 6K 8K 10K 12K");
   NewSegmentAppend("10K 14K");
   CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 14K");
   CheckNoNextBuffer();
 }
 
 // Do not allow splices on top of splices.
 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoDoubleSplice) {
+  InSequence s;
+  EXPECT_MEDIA_LOG_STRING(ContainsGeneratedSpliceLog(3000, 11000));
+  EXPECT_MEDIA_LOG_STRING(
+      HasSubstr("Skipping splice frame generation: overlapped buffers at "
+                "10000us are in a previously buffered splice."));
+
   SetAudioStream();
   Seek(0);
   NewSegmentAppend("0K 2K 4K 6K 8K 10K 12K");
   NewSegmentAppend("11K 13K 15K 17K");
 
   // Verify the splice was created.
   CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 12K C 11K 13K 15K 17K");
   CheckNoNextBuffer();
   Seek(0);
 
@@ skipping 11 matching lines @@
 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoSplice) {
   SetAudioStream();
   Seek(0);
   NewSegmentAppend("0K 2K 4K 6K 8K 10K");
   NewSegmentAppend("12K 14K 16K 18K");
   CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 12K 14K 16K 18K");
   CheckNoNextBuffer();
 }
 
 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_CorrectMediaSegmentStartTime) {
+  EXPECT_MEDIA_LOG_STRING(ContainsGeneratedSpliceLog(5000, 1000));
+
   SetAudioStream();
   Seek(0);
   NewSegmentAppend("0K 2K 4K");
   CheckExpectedRangesByTimestamp("{ [0,6) }");
   NewSegmentAppend("6K 8K 10K");
   CheckExpectedRangesByTimestamp("{ [0,12) }");
   NewSegmentAppend("1K 4D2K");
   CheckExpectedRangesByTimestamp("{ [0,12) }");
   CheckExpectedBuffers("0K 2K 4K C 1K 4K 6K 8K 10K");
   CheckNoNextBuffer();
 }
 
 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_ConfigChange) {
+  EXPECT_MEDIA_LOG_STRING(ContainsGeneratedSpliceLog(3000, 5000));
+
   SetAudioStream();
 
   AudioDecoderConfig new_config(kCodecVorbis,
                                 kSampleFormatPlanarF32,
                                 CHANNEL_LAYOUT_MONO,
                                 1000,
                                 NULL,
                                 0,
                                 false);
   ASSERT_NE(new_config.channel_layout(), audio_config_.channel_layout());
 
   Seek(0);
   CheckAudioConfig(audio_config_);
   NewSegmentAppend("0K 2K 4K 6K");
   stream_->UpdateAudioConfig(new_config);
   NewSegmentAppend("5K 8K 12K");
   CheckExpectedBuffers("0K 2K 4K 6K C 5K 8K 12K");
   CheckAudioConfig(new_config);
   CheckNoNextBuffer();
 }
 
 // Ensure splices are not created if there are not enough frames to crossfade.
 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoTinySplices) {
+  EXPECT_MEDIA_LOG_STRING(HasSubstr(
+      "Skipping splice frame generation: not enough samples for splicing new "
+      "buffer at 1000us. Have 1000us, but need 2000us."));
+
   SetAudioStream();
   Seek(0);
 
   // Overlap the range [0, 2) with [1, 3).  Since each frame has a duration of
   // 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("0D2K");
   CheckExpectedRangesByTimestamp("{ [0,2) }");
   NewSegmentAppend("1D2K");
   CheckExpectedRangesByTimestamp("{ [0,3) }");
   CheckExpectedBuffers("0K 1K");
   CheckNoNextBuffer();
 }
 
 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_NoMillisecondSplices) {
+  EXPECT_MEDIA_LOG_STRING(
+      HasSubstr("Skipping splice frame generation: not enough samples for "
+                "splicing new buffer at 1250us. Have 750us, but need 1000us."));
+
   video_config_ = TestVideoConfig::Invalid();
   audio_config_.Initialize(kCodecVorbis, kSampleFormatPlanarF32,
                            CHANNEL_LAYOUT_STEREO, 4000, NULL, 0, false, false,
                            base::TimeDelta(), 0);
-  stream_.reset(new SourceBufferStream(audio_config_, new MediaLog(), true));
+  stream_.reset(new SourceBufferStream(audio_config_, media_log_, true));
   // Equivalent to 0.5ms per frame.
   SetStreamInfo(2000, 2000);
   Seek(0);
 
   // Append four buffers with a 0.5ms duration each.
   NewSegmentAppend(0, 4);
   CheckExpectedRangesByTimestamp("{ [0,2) }");
 
   // Overlap the range [0, 2) with [1.25, 2); this results in an overlap of
   // 0.75ms between the ranges.
   NewSegmentAppend_OffsetFirstBuffer(2, 2,
                                      base::TimeDelta::FromMillisecondsD(0.25));
   CheckExpectedRangesByTimestamp("{ [0,2) }");
 
   // A splice frame should not be generated (indicated by the lack of a config
   // change in the expected buffer string) since it requires at least 1ms of
   // data to crossfade.
   CheckExpectedBuffers("0K 0K 1K 1K 1K");
   CheckNoNextBuffer();
 }
 
 TEST_F(SourceBufferStreamTest, Audio_SpliceFrame_Preroll) {
+  EXPECT_MEDIA_LOG_STRING(ContainsGeneratedSpliceLog(3000, 11000));
+
   SetAudioStream();
   Seek(0);
   NewSegmentAppend("0K 2K 4K 6K 8K 10K 12K");
   NewSegmentAppend("11P 13K 15K 17K");
   CheckExpectedBuffers("0K 2K 4K 6K 8K 10K 12K C 11P 13K 15K 17K");
   CheckNoNextBuffer();
 }
 
 TEST_F(SourceBufferStreamTest, Audio_PrerollFrame) {
   Seek(0);
@@ skipping 242 matching lines @@
   CheckVideoConfig(video_config_);
   CheckExpectedBuffers("2000K 2010 2020D10");
   CheckVideoConfig(video_config_);
   EXPECT_EQ(stream_->GetNextBuffer(&buffer), SourceBufferStream::kConfigChange);
   CheckVideoConfig(new_config);
   CheckExpectedBuffers("2030K 2040 2050D10");
   CheckNoNextBuffer();
   CheckVideoConfig(new_config);
 }
 
+TEST_F(SourceBufferStreamTest, TrackBuffer_ExhaustionWithSkipForward) {
+  NewSegmentAppend("0K 10 20 30 40");
+
+  // Read the first 4 buffers, so next buffer is at time 40.
+  Seek(0);
+  CheckExpectedRangesByTimestamp("{ [0,50) }");
+  CheckExpectedBuffers("0K 10 20 30");
+
+  // Overlap-append, populating track buffer with timestamp 40 from original
+  // append. Confirm there could be a large jump in time until the next key
+  // frame after exhausting the track buffer.
+  NewSegmentAppend(
+      "31K 41 51 61 71 81 91 101 111 121 "
+      "131K 141");
+  CheckExpectedRangesByTimestamp("{ [0,151) }");
+
+  // Confirm the large jump occurs and warning log is generated.
+  // If this test is changed, update
+  // TrackBufferExhaustion_ImmediateNewTrackBuffer accordingly.
+  EXPECT_MEDIA_LOG_STRING(ContainsTrackBufferExhaustionSkipLog(91));
+
+  CheckExpectedBuffers("40 131K 141");
+  CheckNoNextBuffer();
+}
+
+TEST_F(SourceBufferStreamTest,
+       TrackBuffer_ExhaustionAndImmediateNewTrackBuffer) {
+  NewSegmentAppend("0K 10 20 30 40");
+
+  // Read the first 4 buffers, so next buffer is at time 40.
+  Seek(0);
+  CheckExpectedRangesByTimestamp("{ [0,50) }");
+  CheckExpectedBuffers("0K 10 20 30");
+
+  // Overlap-append
+  NewSegmentAppend(
+      "31K 41 51 61 71 81 91 101 111 121 "
+      "131K 141");
+  CheckExpectedRangesByTimestamp("{ [0,151) }");
+
+  // Exhaust the track buffer, but don't read any of the overlapping append yet.
+  CheckExpectedBuffers("40");
+
+  // Selected range's next buffer is now the 131K buffer from the overlapping
+  // append. (See TrackBuffer_ExhaustionWithSkipForward for that verification.)
+  // Do another overlap-append to immediately create another track buffer and
+  // verify both track buffer exhaustions skip forward and emit log warnings.
+  NewSegmentAppend("22K 32 42 52 62 72 82 92 102 112 122K 132 142 152K 162");
+  CheckExpectedRangesByTimestamp("{ [0,172) }");
+
+  InSequence s;
+  EXPECT_MEDIA_LOG_STRING(ContainsTrackBufferExhaustionSkipLog(91));
+  EXPECT_MEDIA_LOG_STRING(ContainsTrackBufferExhaustionSkipLog(11));
+
+  CheckExpectedBuffers("131K 141 152K 162");
+  CheckNoNextBuffer();
+}
+
 // TODO(vrk): Add unit tests where keyframes are unaligned between streams.
 // (crbug.com/133557)
 
 // TODO(vrk): Add unit tests with end of stream being called at interesting
 // times.
 
 }  // namespace media