MSE: Log a warning if muxed AV media segment has no A or has no V block

media/filters/chunk_demuxer_unittest.cc

Index: media/filters/chunk_demuxer_unittest.cc
diff --git a/media/filters/chunk_demuxer_unittest.cc b/media/filters/chunk_demuxer_unittest.cc
index 2e4983d10d910535f5a956e6d1d1bd4675855e9e..d46c36c648b7c7fdbe38cdef025b91adc75dfbe1 100644
--- a/media/filters/chunk_demuxer_unittest.cc
+++ b/media/filters/chunk_demuxer_unittest.cc
@@ -18,8 +18,8 @@
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decrypt_config.h"
-#include "media/base/media_log.h"
 #include "media/base/mock_demuxer_host.h"
+#include "media/base/mock_media_log.h"
 #include "media/base/test_data_util.h"
 #include "media/base/test_helpers.h"
 #include "media/base/timestamp_constants.h"
@@ -116,6 +116,13 @@ MATCHER_P(HasTimestamp, timestamp_in_ms, "") {
 
 MATCHER(IsEndOfStream, "") { return arg.get() && arg->end_of_stream(); }
 
+MATCHER_P(SegmentMissingFrames, frame_types_string, "") {
+  return CONTAINS_STRING(
+      arg, "Media segment did not contain any " +
+               std::string(frame_types_string) +
+               " coded frames, mismatching initialization segment");
+}
+
 static void OnReadDone(const base::TimeDelta& expected_time,
                        bool* called,
                        DemuxerStream::Status status,
@@ -181,9 +188,12 @@ class ChunkDemuxerTest : public ::testing::Test {
         base::Bind(&ChunkDemuxerTest::DemuxerOpened, base::Unretained(this));
     Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb = base::Bind(
         &ChunkDemuxerTest::OnEncryptedMediaInitData, base::Unretained(this));
-    demuxer_.reset(new ChunkDemuxer(open_cb, encrypted_media_init_data_cb,
-                                    scoped_refptr<MediaLog>(new MediaLog()),
-                                    true));
+    demuxer_.reset(new ChunkDemuxer(
+        open_cb, encrypted_media_init_data_cb,
+        scoped_refptr<MockMediaLog>(new MockMediaLog()), true));
+
+    // BIG TODO start here: use strick mock media log and verify the new media
+    // logs (and any pre-existing ones...)
   }
 
   virtual ~ChunkDemuxerTest() {
@@ -441,6 +451,11 @@ class ChunkDemuxerTest : public ::testing::Test {
   //  should be marked as a key frame. For example "0K 30 60" should populate
   //  |blocks| with 3 BlockInfo objects: a key frame with timestamp 0 and 2
   //  non-key-frames at 30ms and 60ms.
+  //  Every block will be a SimpleBlock, with the exception that the last block
+  //  may have an optional duration delimited with a 'D' and appended to the
+  //  block info timestamp, prior to the optional keyframe 'K'. For example "0K
+  //  30 60D10K" indicates that the last block will be a keyframe BlockGroup
+  //  with duration 10ms.
   void ParseBlockDescriptions(int track_number,
                               const std::string block_descriptions,
                               std::vector<BlockInfo>* blocks) {
@@ -459,6 +474,17 @@ class ChunkDemuxerTest : public ::testing::Test {
         // Remove the "K" off of the token.
         timestamp_str = timestamp_str.substr(0, timestamps[i].length() - 1);
       }
+
+      size_t duration_pos = timestamp_str.find('D');
+      const bool explicit_duration = duration_pos != std::string::npos;
+      const bool is_last_block = i == timestamps.size() - 1;
+      CHECK((!explicit_duration && !is_last_block) || is_last_block);

[chcunningham, 2016/01/07 22:23:56]

I *think* you're trying to assert that

 (explicit_duration -> is_last_block)

If I have this right, its more readable to do 

  CHECK(!explicit_duration || is_last_block);

[wolenetz, 2016/01/07 22:37:09]

Correct.

[wolenetz, 2016/01/16 01:23:35]

Fixed already in landed prereq CL https://codereview.chromium.org/1581003002/

+      if (explicit_duration) {
+        CHECK(base::StringToInt(timestamp_str.substr(duration_pos + 1),
+                                &block_info.duration));
+        timestamp_str = timestamp_str.substr(0, duration_pos);
+      }
+
       CHECK(base::StringToInt(timestamp_str, &block_info.timestamp_in_ms));
 
       if (track_number == kTextTrackNum ||
@@ -642,10 +668,6 @@ class ChunkDemuxerTest : public ::testing::Test {
     EXPECT_EQ(status, expected_status);
   }
 
-  void AppendEmptyCluster(int timecode) {
-    AppendCluster(GenerateEmptyCluster(timecode));
-  }
-
   PipelineStatusCB CreateInitDoneCB(const base::TimeDelta& expected_duration,
                                     PipelineStatus expected_status) {
     if (expected_duration != kNoTimestamp())
@@ -774,7 +796,7 @@ class ChunkDemuxerTest : public ::testing::Test {
     // seen so far for audio track).
     // Last video frame has timestamp 2703 and duration 33 (from TrackEntry
     // DefaultDuration for video track).
-    CheckExpectedRanges(kSourceId, "{ [0,2736) }");
+    CheckExpectedRanges("{ [0,2736) }");
 
     // Append initialization segment for bear2.
     // Note: Offsets here and below are derived from
@@ -787,14 +809,14 @@ class ChunkDemuxerTest : public ::testing::Test {
 
     // Append a media segment that goes from [0.527000, 1.014000).
     AppendData(bear2->data() + 55290, 18785);
-    CheckExpectedRanges(kSourceId, "{ [0,1027) [1201,2736) }");
+    CheckExpectedRanges("{ [0,1027) [1201,2736) }");
 
     // Append initialization segment for bear1 & fill gap with [779-1197)
     // segment.
     EXPECT_CALL(*this, InitSegmentReceived());
     AppendData(bear1->data(), 4370);
     AppendData(bear1->data() + 72737, 28183);
-    CheckExpectedRanges(kSourceId, "{ [0,2736) }");
+    CheckExpectedRanges("{ [0,2736) }");
 
     MarkEndOfStream(PIPELINE_OK);
     return true;
@@ -992,8 +1014,7 @@ class ChunkDemuxerTest : public ::testing::Test {
     CheckExpectedRanges(kSourceId, expected);
   }
 
-  void CheckExpectedRanges(const std::string&  id,
-                           const std::string& expected) {
+  void CheckExpectedRanges(const std::string& id, const std::string& expected) {
     CheckExpectedRanges(demuxer_->GetBufferedRanges(id), expected);
   }
 
@@ -1374,7 +1395,7 @@ TEST_F(ChunkDemuxerTest, SingleTextTrackIdChange) {
       MuxedStreamInfo(kAudioTrackNum, "0K 23K"),
       MuxedStreamInfo(kVideoTrackNum, "0K 30"),
       MuxedStreamInfo(kTextTrackNum, "10K"));
-  CheckExpectedRanges(kSourceId, "{ [0,46) }");
+  CheckExpectedRanges("{ [0,46) }");
 
   scoped_ptr<uint8_t[]> info_tracks;
   int info_tracks_size = 0;
@@ -1393,7 +1414,7 @@ TEST_F(ChunkDemuxerTest, SingleTextTrackIdChange) {
       MuxedStreamInfo(kVideoTrackNum, "60K"),
       MuxedStreamInfo(kAlternateTextTrackNum, "45K"));
 
-  CheckExpectedRanges(kSourceId, "{ [0,92) }");
+  CheckExpectedRanges("{ [0,92) }");
   CheckExpectedBuffers(audio_stream, "0K 23K 46K 69K");
   CheckExpectedBuffers(video_stream, "0K 30 60K");
   CheckExpectedBuffers(text_stream, "10K 45K");
@@ -1422,7 +1443,7 @@ TEST_F(ChunkDemuxerTest, InitSegmentSetsNeedRandomAccessPointFlag) {
       MuxedStreamInfo(kAudioTrackNum, "23K"),
       MuxedStreamInfo(kVideoTrackNum, "0 30K"),
       MuxedStreamInfo(kTextTrackNum, "25K 40K"));
-  CheckExpectedRanges(kSourceId, "{ [23,46) }");
+  CheckExpectedRanges("{ [23,46) }");
 
   EXPECT_CALL(*this, InitSegmentReceived());
   AppendInitSegment(HAS_TEXT | HAS_AUDIO | HAS_VIDEO);
@@ -1430,7 +1451,7 @@ TEST_F(ChunkDemuxerTest, InitSegmentSetsNeedRandomAccessPointFlag) {
       MuxedStreamInfo(kAudioTrackNum, "46K 69K"),
       MuxedStreamInfo(kVideoTrackNum, "60 90K"),
       MuxedStreamInfo(kTextTrackNum, "80K 90K"));
-  CheckExpectedRanges(kSourceId, "{ [23,92) }");
+  CheckExpectedRanges("{ [23,92) }");
 
   CheckExpectedBuffers(audio_stream, "23K 46K 69K");
   CheckExpectedBuffers(video_stream, "30K 90K");
@@ -1919,19 +1940,19 @@ TEST_F(ChunkDemuxerTest, EndOfStreamRangeChanges) {
 
   // Check expected ranges and verify that an empty text track does not
   // affect the expected ranges.
-  CheckExpectedRanges(kSourceId, "{ [0,46) }");
+  CheckExpectedRanges("{ [0,46) }");
 
   EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(66)));
   MarkEndOfStream(PIPELINE_OK);
 
   // Check expected ranges and verify that an empty text track does not
   // affect the expected ranges.
-  CheckExpectedRanges(kSourceId, "{ [0,66) }");
+  CheckExpectedRanges("{ [0,66) }");
 
   // Unmark end of stream state and verify that the ranges return to
   // their pre-"end of stream" values.
   demuxer_->UnmarkEndOfStream();
-  CheckExpectedRanges(kSourceId, "{ [0,46) }");
+  CheckExpectedRanges("{ [0,46) }");
 
   // Add text track data and verify that the buffered ranges don't change
   // since the intersection of all the tracks doesn't change.
@@ -1940,12 +1961,12 @@ TEST_F(ChunkDemuxerTest, EndOfStreamRangeChanges) {
       MuxedStreamInfo(kVideoTrackNum, "0K 33"),
       MuxedStreamInfo(kAudioTrackNum, "0K 23K"),
       MuxedStreamInfo(kTextTrackNum, "0K 100K"));
-  CheckExpectedRanges(kSourceId, "{ [0,46) }");
+  CheckExpectedRanges("{ [0,46) }");
 
   // Mark end of stream and verify that text track data is reflected in
   // the new range.
   MarkEndOfStream(PIPELINE_OK);
-  CheckExpectedRanges(kSourceId, "{ [0,200) }");
+  CheckExpectedRanges("{ [0,200) }");
 }
 
 // Make sure AppendData() will accept elements that span multiple calls.
@@ -2078,7 +2099,6 @@ TEST_F(ChunkDemuxerTest, WebMFile_AltRefFrames) {
 // Verify that we output buffers before the entire cluster has been parsed.
 TEST_F(ChunkDemuxerTest, IncrementalClusterParsing) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
-  AppendEmptyCluster(0);
 
   scoped_ptr<Cluster> cluster(GenerateCluster(0, 6));
 
@@ -2399,8 +2419,11 @@ TEST_F(ChunkDemuxerTest, SeekAudioAndVideoSources) {
 TEST_F(ChunkDemuxerTest, EndOfStreamAfterPastEosSeek) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
-  AppendCluster(GenerateSingleStreamCluster(0, 120, kAudioTrackNum, 10));
-  AppendCluster(GenerateSingleStreamCluster(0, 100, kVideoTrackNum, 5));
+  AppendMuxedCluster(
+      MuxedStreamInfo(kAudioTrackNum,
+                      "0K 10K 20K 30K 40K 50K 60K 70K 80K 90K 100K 110K"),
+      MuxedStreamInfo(kVideoTrackNum, "0K 20K 40K 60K 80K"));
+  CheckExpectedRanges("{ [0,100) }");
 
   // Seeking past the end of video.
   // Note: audio data is available for that seek point.
@@ -2416,6 +2439,7 @@ TEST_F(ChunkDemuxerTest, EndOfStreamAfterPastEosSeek) {
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(120)));
   MarkEndOfStream(PIPELINE_OK);
+  CheckExpectedRanges("{ [0,120) }");
   message_loop_.RunUntilIdle();
 
   EXPECT_TRUE(seek_cb_was_called);
@@ -2428,10 +2452,14 @@ TEST_F(ChunkDemuxerTest, EndOfStreamAfterPastEosSeek) {
 TEST_F(ChunkDemuxerTest, EndOfStreamDuringPendingSeek) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
-  AppendCluster(GenerateSingleStreamCluster(0, 120, kAudioTrackNum, 10));
-  AppendCluster(GenerateSingleStreamCluster(0, 100, kVideoTrackNum, 5));
-  AppendCluster(GenerateSingleStreamCluster(200, 300, kAudioTrackNum, 10));
-  AppendCluster(GenerateSingleStreamCluster(200, 300, kVideoTrackNum, 5));
+  AppendMuxedCluster(
+      MuxedStreamInfo(kAudioTrackNum,
+                      "0K 10K 20K 30K 40K 50K 60K 70K 80K 90K 100K 110K"),
+      MuxedStreamInfo(kVideoTrackNum, "0K 20K 40K 60K 80K"));
+  AppendMuxedCluster(
+      MuxedStreamInfo(kAudioTrackNum,
+                      "200K 210K 220K 230K 240K 250K 260K 270K 280K 290K"),
+      MuxedStreamInfo(kVideoTrackNum, "200K 220K 240K 260K 280K"));
 
   bool seek_cb_was_called = false;
   base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(160);
@@ -2450,8 +2478,10 @@ TEST_F(ChunkDemuxerTest, EndOfStreamDuringPendingSeek) {
 
   demuxer_->UnmarkEndOfStream();
 
-  AppendCluster(GenerateSingleStreamCluster(140, 180, kAudioTrackNum, 10));
-  AppendCluster(GenerateSingleStreamCluster(140, 180, kVideoTrackNum, 5));
+  AppendMuxedCluster(
+      MuxedStreamInfo(kAudioTrackNum, "140K 150K 160K 170K"),
+      MuxedStreamInfo(kVideoTrackNum,
+                      "140K 145K 150K 155K 160K 165K 170K 175K"));
 
   message_loop_.RunUntilIdle();
 
@@ -2514,53 +2544,74 @@ TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioVideo) {
   // Buffered Range: 0 -> 23
   // Audio block duration is smaller than video block duration,
   // so the buffered ranges should correspond to the audio blocks.
-  AppendCluster(GenerateSingleStreamCluster(
-      0, kAudioBlockDuration, kAudioTrackNum, kAudioBlockDuration));
-  AppendCluster(GenerateSingleStreamCluster(
-      0, kVideoBlockDuration, kVideoTrackNum, kVideoBlockDuration));
+  AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "0D23K"),
+                     MuxedStreamInfo(kVideoTrackNum, "0D33K"));
 
+  CheckExpectedRanges(DemuxerStream::AUDIO, "{ [0,23) }");
+  CheckExpectedRanges(DemuxerStream::VIDEO, "{ [0,33) }");
   CheckExpectedRanges("{ [0,23) }");
 
   // Audio: 300 -> 400
   // Video: 320 -> 420

[chcunningham, 2016/01/07 22:23:57]

This is Video: 300 -> 420 now.

[wolenetz, 2016/01/07 22:37:09]

I suppose the comment format isn't clear. The A/V lines in these comments
describe the actual block timecodes+block durations. The Buffered Range line
describes the SourceBuffer.buffered expected retval. I've included new internal
track buffered range expectations, though these are not exposed directly to web
apps for multiple tracks within the same muxed SourceBuffer. I'll see if I can
make the comments clearer regarding this.

[wolenetz, 2016/01/16 01:23:35]

Done.

-  // Buffered Range: 320 -> 400  (end overlap)
-  AppendCluster(GenerateSingleStreamCluster(300, 400, kAudioTrackNum, 50));
-  AppendCluster(GenerateSingleStreamCluster(320, 420, kVideoTrackNum, 50));
+  // Naive Buffered Range: 320 -> 400  (end overlap) **
+  // **Except these are in the same cluster, with same segment start time of
+  // 300, so the added buffered range is 300 -> 400  (still with end overlap)
+  AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "300K 350D50K"),
+                     MuxedStreamInfo(kVideoTrackNum, "320K 370D50K"));
 
-  CheckExpectedRanges("{ [0,23) [320,400) }");
+  CheckExpectedRanges(DemuxerStream::AUDIO, "{ [0,23) [300,400) }");
+  CheckExpectedRanges(DemuxerStream::VIDEO, "{ [0,33) [300,420) }");
+  CheckExpectedRanges("{ [0,23) [300,400) }");
 
   // Audio: 520 -> 590
   // Video: 500 -> 570
-  // Buffered Range: 520 -> 570  (front overlap)
-  AppendCluster(GenerateSingleStreamCluster(520, 590, kAudioTrackNum, 70));
-  AppendCluster(GenerateSingleStreamCluster(500, 570, kVideoTrackNum, 70));
+  // Naive Buffered Range: 520 -> 570  (front overlap) **
+  // **Except these are in the same cluster, with same segment start time of
+  // 500, so the added buffered range is 500 -> 570

[chcunningham, 2016/01/07 22:23:57]

Is this due to the fudgy start stuff? 

[wolenetz, 2016/01/07 22:37:09]

While it seems similar, the fudgy start stuff is meant to equate a slightly
non-zero first-range-start time in [0,1s) to not cause stalls on playback.

These "naive" buffered ranges do not consider that the source of the buffers was
in a muxed media segment, for which the content creator expected playback for
all tracks to be able to begin on the first coded frame group for each track
encountered within that segment, regardless of if it starts precisely at the
segment start time. There's a bit of legacy cruft in here, but this at least
doesn't change the current behavior of SourceBufferStreams in a muxed
SourceBuffer relative to the muxed clusters' cluster timecode (or media segment
start time).

+  AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "520D70K"),
+                     MuxedStreamInfo(kVideoTrackNum, "500D70K"));
 
-  CheckExpectedRanges("{ [0,23) [320,400) [520,570) }");
+  CheckExpectedRanges(DemuxerStream::AUDIO, "{ [0,23) [300,400) [500,590) }");
+  CheckExpectedRanges(DemuxerStream::VIDEO, "{ [0,33) [300,420) [500,570) }");
+  CheckExpectedRanges("{ [0,23) [300,400) [500,570) }");
 
   // Audio: 720 -> 750
   // Video: 700 -> 770
-  // Buffered Range: 720 -> 750  (complete overlap, audio)
-  AppendCluster(GenerateSingleStreamCluster(720, 750, kAudioTrackNum, 30));
-  AppendCluster(GenerateSingleStreamCluster(700, 770, kVideoTrackNum, 70));
-
-  CheckExpectedRanges("{ [0,23) [320,400) [520,570) [720,750) }");
+  // Naive Buffered Range: 720 -> 750  (complete overlap, audio) **
+  // **Except these are in the same cluster, with same segment start time of
+  // 700, so the added buffered range is 700 -> 750

[chcunningham, 2016/01/07 22:23:57]

Do we now need to add a test where we have 2 SourceBuffers with jagged start so
we can see the naive buffered range actually come to be the reported buffered
range?

[wolenetz, 2016/01/07 22:37:09]

SGTM.

[wolenetz, 2016/01/16 01:23:35]

Done.

+  AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "720D30K"),
+                     MuxedStreamInfo(kVideoTrackNum, "700D70K"));
+
+  CheckExpectedRanges(DemuxerStream::AUDIO,
+                      "{ [0,23) [300,400) [500,590) [700,750) }");
+  CheckExpectedRanges(DemuxerStream::VIDEO,
+                      "{ [0,33) [300,420) [500,570) [700,770) }");
+  CheckExpectedRanges("{ [0,23) [300,400) [500,570) [700,750) }");
 
   // Audio: 900 -> 970
   // Video: 920 -> 950
-  // Buffered Range: 920 -> 950  (complete overlap, video)
-  AppendCluster(GenerateSingleStreamCluster(900, 970, kAudioTrackNum, 70));
-  AppendCluster(GenerateSingleStreamCluster(920, 950, kVideoTrackNum, 30));
-
-  CheckExpectedRanges("{ [0,23) [320,400) [520,570) [720,750) [920,950) }");
+  // Naive Buffered Range: 920 -> 950  (complete overlap, video) **
+  // **Except these are in the same cluster, with same segment start time of
+  // 900, so the added buffered range is 900 -> 950
+  AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "900D70K"),
+                     MuxedStreamInfo(kVideoTrackNum, "920D30K"));
+
+  CheckExpectedRanges(DemuxerStream::AUDIO,
+                      "{ [0,23) [300,400) [500,590) [700,750) [900,970) }");
+  CheckExpectedRanges(DemuxerStream::VIDEO,
+                      "{ [0,33) [300,420) [500,570) [700,770) [900,950) }");
+  CheckExpectedRanges("{ [0,23) [300,400) [500,570) [700,750) [900,950) }");
 
   // Appending within buffered range should not affect buffered ranges.
-  AppendCluster(GenerateSingleStreamCluster(930, 950, kAudioTrackNum, 20));
-  CheckExpectedRanges("{ [0,23) [320,400) [520,570) [720,750) [920,950) }");
+  AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "930D20K"),
+                     MuxedStreamInfo(kVideoTrackNum, "930D20K"));
 
-  // Appending to single stream outside buffered ranges should not affect
-  // buffered ranges.
-  AppendCluster(GenerateSingleStreamCluster(1230, 1240, kVideoTrackNum, 10));
-  CheckExpectedRanges("{ [0,23) [320,400) [520,570) [720,750) [920,950) }");
+  CheckExpectedRanges(DemuxerStream::AUDIO,
+                      "{ [0,23) [300,400) [500,590) [700,750) [900,970) }");
+  CheckExpectedRanges(DemuxerStream::VIDEO,
+                      "{ [0,33) [300,420) [500,570) [700,770) [900,950) }");
+  CheckExpectedRanges("{ [0,23) [300,400) [500,570) [700,750) [900,950) }");
 }
 
 TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioVideoText) {
@@ -2714,12 +2765,8 @@ TEST_F(ChunkDemuxerTest, ClusterWithNoBuffers) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   // Generate and append an empty cluster beginning at 0.
-  AppendEmptyCluster(0);
-
-  // Sanity check that data can be appended after this cluster correctly.
-  AppendCluster(GenerateCluster(0, 2));
-  ExpectRead(DemuxerStream::AUDIO, 0);
-  ExpectRead(DemuxerStream::VIDEO, 0);
+  EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
+  AppendCluster(GenerateEmptyCluster(0));
 }
 
 TEST_F(ChunkDemuxerTest, CodecPrefixMatching) {
@@ -3136,27 +3183,59 @@ TEST_F(ChunkDemuxerTest, SeekCompleteDuringAbort) {
 
 TEST_F(ChunkDemuxerTest, WebMIsParsingMediaSegmentDetection) {
   const uint8_t kBuffer[] = {
-      0x1F, 0x43, 0xB6, 0x75, 0x83,  // CLUSTER (size = 3)
-      0xE7, 0x81, 0x01,              // Cluster TIMECODE (value = 1)
-
-      0x1F, 0x43, 0xB6, 0x75,
-      0xFF,              // CLUSTER (size = unknown; really 3 due to:)
-      0xE7, 0x81, 0x02,  // Cluster TIMECODE (value = 2)
-      /* e.g. put some blocks here... */
-      0x1A, 0x45, 0xDF, 0xA3,
+      0x1F,
+      0x43,
+      0xB6,
+      0x75,
+      0x8A,  // CLUSTER (size = 10)
+      0xE7,
+      0x81,
+      0x01,  // Cluster TIMECODE (value = 1)
+

[chcunningham, 2016/01/07 22:23:56]

This space seems kinda random?

[wolenetz, 2016/01/07 22:37:09]

Yep. Per my PTAL PS1 comment, git cl format did bad things. I'll fix this.

[wolenetz, 2016/01/16 01:23:35]

Done.

+      0xA3,
+      0x85,                            // SIMPLEBLOCK (size = 5)
+      0x80 | (kAudioTrackNum & 0x7F),  // Audio Track Number
+      0x00,
+      0x00,  // Timecode (relative to cluster) (value = 0)
+      0x80,  // Keyframe flag
+      0x00,  // Fake block data
+
+      0x1F,
+      0x43,
+      0xB6,
+      0x75,
+      0xFF,  // CLUSTER (size = unknown; really 10 due to:)
+      0xE7,
+      0x81,
+      0x02,  // Cluster TIMECODE (value = 2)
+

[chcunningham, 2016/01/07 22:23:56]

ditto

[wolenetz, 2016/01/07 22:37:09]

ditto

[wolenetz, 2016/01/16 01:23:35]

Done.

+      0xA3,
+      0x85,                            // SIMPLEBLOCK (size = 5)
+      0x80 | (kAudioTrackNum & 0x7F),  // Audio Track Number
+      0x00,
+      0x00,  // Timecode (relative to cluster) (value = 0)
+      0x80,  // Keyframe flag
+      0x00,  // Fake block data
+

[chcunningham, 2016/01/07 22:23:57]

ditto

[wolenetz, 2016/01/07 22:37:09]

ditto

[wolenetz, 2016/01/16 01:23:35]

Done.

+      0x1A,
+      0x45,
+      0xDF,
+      0xA3,
       0x8A,  // EBMLHEADER (size = 10, not fully appended)
   };
 
   // This array indicates expected return value of IsParsingMediaSegment()
   // following each incrementally appended byte in |kBuffer|.
   const bool kExpectedReturnValues[] = {
-    false, false, false, false, true,
-    true, true, false,
+      false, false, false, false, true,  true, true,  true,
+
+      true,  true,  true,  true,  true,  true, false,
 
-    false, false, false, false, true,
-    true, true, true,
+      false, false, false, false, true,  true, true,  true,
 
-    true, true, true, true, false,
+      true,  true,  true,  true,  true,  true, true,
+
+      true,  true,  true,  true,  false,
   };
 
   static_assert(arraysize(kBuffer) == arraysize(kExpectedReturnValues),
@@ -3164,7 +3243,7 @@ TEST_F(ChunkDemuxerTest, WebMIsParsingMediaSegmentDetection) {
   static_assert(arraysize(kBuffer) == sizeof(kBuffer),
       "there should be one byte per index");
 
-  ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
+  ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
 
   for (size_t i = 0; i < sizeof(kBuffer); i++) {
     DVLOG(3) << "Appending and testing index " << i;
@@ -3184,7 +3263,7 @@ TEST_F(ChunkDemuxerTest, DurationChange) {
                                 kStreamDuration - kVideoBlockDuration,
                                 2));
 
-  CheckExpectedRanges(kSourceId, "{ [201191,201224) }");
+  CheckExpectedRanges("{ [201191,201224) }");
 
   // Add data beginning at the currently set duration and expect a new duration
   // to be signaled. Note that the last video block will have a higher end
@@ -3194,7 +3273,7 @@ TEST_F(ChunkDemuxerTest, DurationChange) {
       base::TimeDelta::FromMilliseconds(kNewStreamDurationVideo)));
   AppendCluster(GenerateCluster(kDefaultDuration().InMilliseconds(), 2));
 
-  CheckExpectedRanges(kSourceId, "{ [201191,201247) }");
+  CheckExpectedRanges("{ [201191,201247) }");
 
   // Add more data to the end of each media type. Note that the last audio block
   // will have a higher end timestamp than the last video block.
@@ -3207,7 +3286,7 @@ TEST_F(ChunkDemuxerTest, DurationChange) {
 
   // See that the range has increased appropriately (but not to the full
   // duration of 201293, since there is not enough video appended for that).
-  CheckExpectedRanges(kSourceId, "{ [201191,201290) }");
+  CheckExpectedRanges("{ [201191,201290) }");
 }
 
 TEST_F(ChunkDemuxerTest, DurationChangeTimestampOffset) {
@@ -3267,7 +3346,7 @@ TEST_F(ChunkDemuxerTest, EndOfStreamWhileWaitingForGapToBeFilled) {
 
   AppendCluster(0, 10);
   AppendCluster(300, 10);
-  CheckExpectedRanges(kSourceId, "{ [0,132) [300,432) }");
+  CheckExpectedRanges("{ [0,132) [300,432) }");
 
   GenerateExpectedReads(0, 10);
 
@@ -3297,7 +3376,7 @@ TEST_F(ChunkDemuxerTest, EndOfStreamWhileWaitingForGapToBeFilled) {
 
   message_loop_.RunUntilIdle();
 
-  CheckExpectedRanges(kSourceId, "{ [0,435) }");
+  CheckExpectedRanges("{ [0,435) }");
 
   // Verify that the reads have completed.
   EXPECT_TRUE(audio_read_done);
@@ -3349,8 +3428,10 @@ TEST_F(ChunkDemuxerTest, SetMemoryLimitType) {
   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);
+  AppendMuxedCluster(
+      MuxedStreamInfo(kAudioTrackNum,
+                      "0K 23K 46K 69K 92K 115K 138K 161K 184K 207K"),
+      MuxedStreamInfo(kVideoTrackNum, "0K 33K 66K 99K 132K"));
 
   // We should be right at buffer limit, should pass
   EXPECT_TRUE(demuxer_->EvictCodedFrames(
@@ -3363,10 +3444,11 @@ TEST_F(ChunkDemuxerTest, SetMemoryLimitType) {
   Seek(seek_time);
 
   // Append data at seek_time.
-  AppendSingleStreamCluster(kSourceId, kAudioTrackNum,
-                            seek_time.InMilliseconds(), 10);
-  AppendSingleStreamCluster(kSourceId, kVideoTrackNum,
-                            seek_time.InMilliseconds(), 5);
+  AppendMuxedCluster(
+      MuxedStreamInfo(
+          kAudioTrackNum,
+          "1000K 1023K 1046K 1069K 1092K 1115K 1138K 1161K 1184K 1207K"),
+      MuxedStreamInfo(kVideoTrackNum, "1000K 1033K 1066K 1099K 1132K"));
 
   // We should delete first append, and be exactly at buffer limit
   EXPECT_TRUE(demuxer_->EvictCodedFrames(kSourceId, seek_time, 0));
@@ -3381,7 +3463,7 @@ TEST_F(ChunkDemuxerTest, GCDuringSeek_SingleRange_SeekForward) {
   demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 10 * kBlockSize);
   // Append some data at position 1000ms
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 1000, 10);
-  CheckExpectedRanges(kSourceId, "{ [1000,1230) }");
+  CheckExpectedRanges("{ [1000,1230) }");
 
   // GC should be able to evict frames in the currently buffered range, since
   // those frames are earlier than the seek target position.
@@ -3391,7 +3473,7 @@ TEST_F(ChunkDemuxerTest, GCDuringSeek_SingleRange_SeekForward) {
 
   // Append data to complete seek operation
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 2000, 5);
-  CheckExpectedRanges(kSourceId, "{ [1115,1230) [2000,2115) }");
+  CheckExpectedRanges("{ [1115,1230) [2000,2115) }");
 }
 
 TEST_F(ChunkDemuxerTest, GCDuringSeek_SingleRange_SeekBack) {
@@ -3399,7 +3481,7 @@ TEST_F(ChunkDemuxerTest, GCDuringSeek_SingleRange_SeekBack) {
   demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 10 * kBlockSize);
   // Append some data at position 1000ms
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 1000, 10);
-  CheckExpectedRanges(kSourceId, "{ [1000,1230) }");
+  CheckExpectedRanges("{ [1000,1230) }");
 
   // GC should be able to evict frames in the currently buffered range, since
   // seek target position has no data and so we should allow some frames to be
@@ -3410,7 +3492,7 @@ TEST_F(ChunkDemuxerTest, GCDuringSeek_SingleRange_SeekBack) {
 
   // Append data to complete seek operation
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 0, 5);
-  CheckExpectedRanges(kSourceId, "{ [0,115) [1115,1230) }");
+  CheckExpectedRanges("{ [0,115) [1115,1230) }");
 }
 
 TEST_F(ChunkDemuxerTest, GCDuringSeek_MultipleRanges_SeekForward) {
@@ -3419,7 +3501,7 @@ TEST_F(ChunkDemuxerTest, GCDuringSeek_MultipleRanges_SeekForward) {
   // Append some data at position 1000ms then at 2000ms
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 1000, 5);
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 2000, 5);
-  CheckExpectedRanges(kSourceId, "{ [1000,1115) [2000,2115) }");
+  CheckExpectedRanges("{ [1000,1115) [2000,2115) }");
 
   // GC should be able to evict frames in the currently buffered ranges, since
   // those frames are earlier than the seek target position.
@@ -3429,7 +3511,7 @@ TEST_F(ChunkDemuxerTest, GCDuringSeek_MultipleRanges_SeekForward) {
 
   // Append data to complete seek operation
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 3000, 5);
-  CheckExpectedRanges(kSourceId, "{ [2069,2115) [3000,3115) }");
+  CheckExpectedRanges("{ [2069,2115) [3000,3115) }");
 }
 
 TEST_F(ChunkDemuxerTest, GCDuringSeek_MultipleRanges_SeekInbetween1) {
@@ -3438,7 +3520,7 @@ TEST_F(ChunkDemuxerTest, GCDuringSeek_MultipleRanges_SeekInbetween1) {
   // Append some data at position 1000ms then at 2000ms
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 1000, 5);
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 2000, 5);
-  CheckExpectedRanges(kSourceId, "{ [1000,1115) [2000,2115) }");
+  CheckExpectedRanges("{ [1000,1115) [2000,2115) }");
 
   // GC should be able to evict all frames from the first buffered range, since
   // those frames are earlier than the seek target position. But there's only 5
@@ -3454,7 +3536,7 @@ TEST_F(ChunkDemuxerTest, GCDuringSeek_MultipleRanges_SeekInbetween1) {
 
   // Append data to complete seek operation
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 1500, 5);
-  CheckExpectedRanges(kSourceId, "{ [1500,1615) [2069,2115) }");
+  CheckExpectedRanges("{ [1500,1615) [2069,2115) }");
 }
 
 TEST_F(ChunkDemuxerTest, GCDuringSeek_MultipleRanges_SeekInbetween2) {
@@ -3466,7 +3548,7 @@ TEST_F(ChunkDemuxerTest, GCDuringSeek_MultipleRanges_SeekInbetween2) {
   // GC algorithm since it tries to preserve more recently appended data).
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 2000, 5);
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 1000, 5);
-  CheckExpectedRanges(kSourceId, "{ [1000,1115) [2000,2115) }");
+  CheckExpectedRanges("{ [1000,1115) [2000,2115) }");
 
   // Now try performing garbage collection without announcing seek first, i.e.
   // without calling Seek(), the GC algorithm should try to preserve data in the
@@ -3475,7 +3557,7 @@ TEST_F(ChunkDemuxerTest, GCDuringSeek_MultipleRanges_SeekInbetween2) {
   EXPECT_TRUE(demuxer_->EvictCodedFrames(kSourceId, seek_time, 5 * kBlockSize));
 
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 1500, 5);
-  CheckExpectedRanges(kSourceId, "{ [1000,1115) [1500,1615) }");
+  CheckExpectedRanges("{ [1000,1115) [1500,1615) }");
 }
 
 TEST_F(ChunkDemuxerTest, GCDuringSeek_MultipleRanges_SeekBack) {
@@ -3484,7 +3566,7 @@ TEST_F(ChunkDemuxerTest, GCDuringSeek_MultipleRanges_SeekBack) {
   // Append some data at position 1000ms then at 2000ms
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 1000, 5);
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 2000, 5);
-  CheckExpectedRanges(kSourceId, "{ [1000,1115) [2000,2115) }");
+  CheckExpectedRanges("{ [1000,1115) [2000,2115) }");
 
   // GC should be able to evict frames in the currently buffered ranges, since
   // those frames are earlier than the seek target position.
@@ -3494,7 +3576,7 @@ TEST_F(ChunkDemuxerTest, GCDuringSeek_MultipleRanges_SeekBack) {
 
   // Append data to complete seek operation
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 0, 5);
-  CheckExpectedRanges(kSourceId, "{ [0,115) [2069,2115) }");
+  CheckExpectedRanges("{ [0,115) [2069,2115) }");
 }
 
 TEST_F(ChunkDemuxerTest, GCDuringSeek) {
@@ -3511,11 +3593,11 @@ TEST_F(ChunkDemuxerTest, GCDuringSeek) {
   // Append data to satisfy the first seek request.
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum,
                             seek_time1.InMilliseconds(), 5);
-  CheckExpectedRanges(kSourceId, "{ [1000,1115) }");
+  CheckExpectedRanges("{ [1000,1115) }");
 
   // We are under memory limit, so Evict should be a no-op.
   EXPECT_TRUE(demuxer_->EvictCodedFrames(kSourceId, seek_time1, 0));
-  CheckExpectedRanges(kSourceId, "{ [1000,1115) }");
+  CheckExpectedRanges("{ [1000,1115) }");
 
   // Signal that the second seek is starting.
   demuxer_->StartWaitingForSeek(seek_time2);
@@ -3523,13 +3605,13 @@ TEST_F(ChunkDemuxerTest, GCDuringSeek) {
   // Append data to satisfy the second seek.
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum,
                             seek_time2.InMilliseconds(), 5);
-  CheckExpectedRanges(kSourceId, "{ [500,615) [1000,1115) }");
+  CheckExpectedRanges("{ [500,615) [1000,1115) }");
 
   // We are now over our memory usage limit. We have just seeked to |seek_time2|
   // so data around 500ms position should be preserved, while the previous
   // append at 1000ms should be removed.
   EXPECT_TRUE(demuxer_->EvictCodedFrames(kSourceId, seek_time2, 0));
-  CheckExpectedRanges(kSourceId, "{ [500,615) }");
+  CheckExpectedRanges("{ [500,615) }");
 
   // Complete the seek.
   demuxer_->Seek(seek_time2, NewExpectedStatusCB(PIPELINE_OK));
@@ -3539,7 +3621,7 @@ TEST_F(ChunkDemuxerTest, GCDuringSeek) {
   // 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) }");
+  CheckExpectedRanges("{ [500,615) [700,815) }");
 }
 
 TEST_F(ChunkDemuxerTest, GCKeepPlayhead) {
@@ -3549,26 +3631,26 @@ TEST_F(ChunkDemuxerTest, GCKeepPlayhead) {
 
   // Append data at the start that can be garbage collected:
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 0, 10);
-  CheckExpectedRanges(kSourceId, "{ [0,230) }");
+  CheckExpectedRanges("{ [0,230) }");
 
   // We expect garbage collection to fail, as we don't want to spontaneously
   // create gaps in source buffer stream. Gaps could break playback for many
   // clients, who don't bother to check ranges after append.
   EXPECT_FALSE(demuxer_->EvictCodedFrames(
       kSourceId, base::TimeDelta::FromMilliseconds(0), 0));
-  CheckExpectedRanges(kSourceId, "{ [0,230) }");
+  CheckExpectedRanges("{ [0,230) }");
 
   // Increase media_time a bit, this will allow some data to be collected, but
   // we are still over memory usage limit.
   base::TimeDelta seek_time1 = base::TimeDelta::FromMilliseconds(23*2);
   Seek(seek_time1);
   EXPECT_FALSE(demuxer_->EvictCodedFrames(kSourceId, seek_time1, 0));
-  CheckExpectedRanges(kSourceId, "{ [46,230) }");
+  CheckExpectedRanges("{ [46,230) }");
 
   base::TimeDelta seek_time2 = base::TimeDelta::FromMilliseconds(23*4);
   Seek(seek_time2);
   EXPECT_FALSE(demuxer_->EvictCodedFrames(kSourceId, seek_time2, 0));
-  CheckExpectedRanges(kSourceId, "{ [92,230) }");
+  CheckExpectedRanges("{ [92,230) }");
 
   // media_time has progressed to a point where we can collect enough data to
   // be under memory limit, so Evict should return true.
@@ -3578,7 +3660,7 @@ TEST_F(ChunkDemuxerTest, GCKeepPlayhead) {
   // Strictly speaking the current playback time is 23*6==138ms, so we could
   // release data up to 138ms, but we only release as much data as necessary
   // to bring memory usage under the limit, so we release only up to 115ms.
-  CheckExpectedRanges(kSourceId, "{ [115,230) }");
+  CheckExpectedRanges("{ [115,230) }");
 }
 
 TEST_F(ChunkDemuxerTest, AppendWindow_Video) {
@@ -3596,7 +3678,7 @@ TEST_F(ChunkDemuxerTest, AppendWindow_Video) {
   // Verify that GOPs that start outside the window are not included
   // in the buffer. Also verify that buffers that start inside the
   // window and extend beyond the end of the window are not included.
-  CheckExpectedRanges(kSourceId, "{ [120,270) }");
+  CheckExpectedRanges("{ [120,270) }");
   CheckExpectedBuffers(stream, "120K 150 180 210 240K");
 
   // Extend the append window to [50,650).
@@ -3606,7 +3688,7 @@ TEST_F(ChunkDemuxerTest, AppendWindow_Video) {
   // key frame.
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum,
                             "360 390 420K 450 480 510 540K 570 600 630K");
-  CheckExpectedRanges(kSourceId, "{ [120,270) [420,630) }");
+  CheckExpectedRanges("{ [120,270) [420,630) }");
 }
 
 TEST_F(ChunkDemuxerTest, AppendWindow_Audio) {
@@ -3628,7 +3710,7 @@ TEST_F(ChunkDemuxerTest, AppendWindow_Audio) {
   //
   // The first 50ms of the range should be truncated since it overlaps
   // the start of the append window.
-  CheckExpectedRanges(kSourceId, "{ [50,280) }");
+  CheckExpectedRanges("{ [50,280) }");
 
   // The "50P" buffer is the "0" buffer marked for complete discard.  The next
   // "50" buffer is the "30" buffer marked with 20ms of start discard.
@@ -3641,7 +3723,7 @@ TEST_F(ChunkDemuxerTest, AppendWindow_Audio) {
   AppendSingleStreamCluster(
       kSourceId, kAudioTrackNum,
       "360K 390K 420K 450K 480K 510K 540K 570K 600K 630K");
-  CheckExpectedRanges(kSourceId, "{ [50,280) [360,650) }");
+  CheckExpectedRanges("{ [50,280) [360,650) }");
 }
 
 TEST_F(ChunkDemuxerTest, AppendWindow_AudioOverlapStartAndEnd) {
@@ -3655,7 +3737,7 @@ TEST_F(ChunkDemuxerTest, AppendWindow_AudioOverlapStartAndEnd) {
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, "0K");
 
   // Verify the append is clipped to the append window.
-  CheckExpectedRanges(kSourceId, "{ [10,20) }");
+  CheckExpectedRanges("{ [10,20) }");
 }
 
 TEST_F(ChunkDemuxerTest, AppendWindow_WebMFile_AudioOnly) {
@@ -3702,7 +3784,7 @@ TEST_F(ChunkDemuxerTest, AppendWindow_AudioConfigUpdateRemovesPreroll) {
       ReadTestDataFile("bear-320x240-audio-only.webm");
   EXPECT_CALL(*this, InitSegmentReceived());
   AppendDataInPieces(buffer->data(), buffer->data_size(), 512);
-  CheckExpectedRanges(kSourceId, "{ }");
+  CheckExpectedRanges("{ }");
 
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   AudioDecoderConfig config_1 = stream->audio_decoder_config();
@@ -3714,7 +3796,7 @@ TEST_F(ChunkDemuxerTest, AppendWindow_AudioConfigUpdateRemovesPreroll) {
   EXPECT_CALL(host_, SetDuration(_)).Times(AnyNumber());
   ASSERT_TRUE(SetTimestampOffset(kSourceId, duration_1));
   AppendDataInPieces(buffer2->data(), buffer2->data_size(), 512);
-  CheckExpectedRanges(kSourceId, "{ [2746,5519) }");
+  CheckExpectedRanges("{ [2746,5519) }");
 
   Seek(duration_1);
   ExpectConfigChanged(DemuxerStream::AUDIO);
@@ -3743,7 +3825,7 @@ TEST_F(ChunkDemuxerTest, AppendWindow_Text) {
   // Verify that text cues that start outside the window are not included
   // in the buffer. Also verify that cues that extend beyond the
   // window are not included.
-  CheckExpectedRanges(kSourceId, "{ [100,270) }");
+  CheckExpectedRanges("{ [100,270) }");
   CheckExpectedBuffers(video_stream, "120K 150 180 210 240K");
   CheckExpectedBuffers(text_stream, "100K");
 
@@ -3755,7 +3837,7 @@ TEST_F(ChunkDemuxerTest, AppendWindow_Text) {
       MuxedStreamInfo(kVideoTrackNum,
                       "360 390 420K 450 480 510 540K 570 600 630K"),
       MuxedStreamInfo(kTextTrackNum, "400K 500K 600K 700K" ));
-  CheckExpectedRanges(kSourceId, "{ [100,270) [400,630) }");
+  CheckExpectedRanges("{ [100,270) [400,630) }");
 
   // Seek to the new range and verify that the expected buffers are returned.
   Seek(base::TimeDelta::FromMilliseconds(420));
@@ -3794,7 +3876,7 @@ TEST_F(ChunkDemuxerTest, Remove_AudioVideoText) {
                    base::TimeDelta::FromMilliseconds(300));
 
   // Verify that all the appended data has been removed.
-  CheckExpectedRanges(kSourceId, "{ }");
+  CheckExpectedRanges("{ }");
 
   // Append new buffers that are clearly different than the original
   // ones and verify that only the new buffers are returned.
@@ -3824,7 +3906,7 @@ TEST_F(ChunkDemuxerTest, Remove_StartAtDuration) {
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum,
                             "0K 20K 40K 60K 80K 100K 120K 140K");
 
-  CheckExpectedRanges(kSourceId, "{ [0,160) }");
+  CheckExpectedRanges("{ [0,160) }");
   CheckExpectedBuffers(audio_stream, "0K 20K 40K 60K 80K 100K 120K 140K");
 
   demuxer_->Remove(kSourceId,
@@ -3832,7 +3914,7 @@ TEST_F(ChunkDemuxerTest, Remove_StartAtDuration) {
                    kInfiniteDuration());
 
   Seek(base::TimeDelta());
-  CheckExpectedRanges(kSourceId, "{ [0,160) }");
+  CheckExpectedRanges("{ [0,160) }");
   CheckExpectedBuffers(audio_stream, "0K 20K 40K 60K 80K 100K 120K 140K");
 }
 
@@ -3901,11 +3983,11 @@ TEST_F(ChunkDemuxerTest, ClusterWithUnknownSize) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   AppendCluster(GenerateCluster(0, 0, 4, true));
-  CheckExpectedRanges(kSourceId, "{ [0,46) }");
+  CheckExpectedRanges("{ [0,46) }");
 
   // A new cluster indicates end of the previous cluster with unknown size.
   AppendCluster(GenerateCluster(46, 66, 5, true));
-  CheckExpectedRanges(kSourceId, "{ [0,115) }");
+  CheckExpectedRanges("{ [0,115) }");
 }
 
 TEST_F(ChunkDemuxerTest, CuesBetweenClustersWithUnknownSize) {
@@ -3919,7 +4001,7 @@ TEST_F(ChunkDemuxerTest, CuesBetweenClustersWithUnknownSize) {
   data.insert(data.end(), cluster->data(), cluster->data() + cluster->size());
   AppendData(&*data.begin(), data.size());
 
-  CheckExpectedRanges(kSourceId, "{ [0,115) }");
+  CheckExpectedRanges("{ [0,115) }");
 }
 
 TEST_F(ChunkDemuxerTest, CuesBetweenClusters) {
@@ -3928,7 +4010,7 @@ TEST_F(ChunkDemuxerTest, CuesBetweenClusters) {
   AppendCluster(GenerateCluster(0, 0, 4));
   AppendData(kCuesHeader, sizeof(kCuesHeader));
   AppendCluster(GenerateCluster(46, 66, 5));
-  CheckExpectedRanges(kSourceId, "{ [0,115) }");
+  CheckExpectedRanges("{ [0,115) }");
 }
 
 TEST_F(ChunkDemuxerTest, EvictCodedFramesTest) {
@@ -3982,4 +4064,29 @@ TEST_F(ChunkDemuxerTest, EvictCodedFramesTest) {
   CheckExpectedBuffers(video_stream, "60K 70 80K 90 100K 110 120K 130 140K");
 }
 
+TEST_F(ChunkDemuxerTest, SegmentMissingAudioFrame_AudioOnly) {

[chcunningham, 2016/01/07 22:23:57]

These are work-in-progress I think?

[wolenetz, 2016/01/07 22:37:09]

Correct. I need to add strict medialog expectations, at minimum.

[wolenetz, 2016/01/16 01:23:35]

Done.

+  ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
+  AppendCluster(GenerateEmptyCluster(0));
+}
+
+TEST_F(ChunkDemuxerTest, SegmentMissingVideoFrame_VideoOnly) {
+  ASSERT_TRUE(InitDemuxer(HAS_VIDEO));
+  AppendCluster(GenerateEmptyCluster(0));
+}
+
+TEST_F(ChunkDemuxerTest, SegmentMissingAudioFrame_AudioVideo) {
+  ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
+  AppendSingleStreamCluster(kSourceId, kVideoTrackNum, 0, 10);
+}
+
+TEST_F(ChunkDemuxerTest, SegmentMissingVideoFrame_AudioVideo) {
+  ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
+  AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 0, 10);
+}
+
+TEST_F(ChunkDemuxerTest, SegmentMissingAudioVideoFrames) {
+  ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
+  AppendCluster(GenerateEmptyCluster(0));
+}
+
 }  // namespace media