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

media/filters/chunk_demuxer_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/filters/chunk_demuxer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
@@ skipping 101 matching lines @@
   }
 }
 
 MATCHER_P(HasTimestamp, timestamp_in_ms, "") {
   return arg.get() && !arg->end_of_stream() &&
          arg->timestamp().InMilliseconds() == 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. Therefore, MSE coded frame "
+                                  "processing may not interoperably detect "
+                                  "discontinuities in appended media.");
+}
+
 MATCHER(StreamParsingFailed, "") {
   return CONTAINS_STRING(arg, "Append: stream parsing failed.");
 }
 
 MATCHER_P(FoundStream, stream_type_string, "") {
   return CONTAINS_STRING(
              arg, "found_" + std::string(stream_type_string) + "_stream") &&
          CONTAINS_STRING(arg, "true");
 }
 
@@ skipping 621 matching lines @@
     for (int i = 0; i < garbage_cluster_size; ++i)
       garbage_cluster[i] = i;
     AppendData(garbage_cluster.get(), garbage_cluster_size);
   }
 
   void InitDoneCalled(PipelineStatus expected_status,
                       PipelineStatus status) {
     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())
       EXPECT_CALL(host_, SetDuration(expected_duration));
     return CreateInitDoneCB(expected_status);
   }
 
   PipelineStatusCB CreateInitDoneCB(PipelineStatus expected_status) {
     return base::Bind(&ChunkDemuxerTest::InitDoneCalled,
                       base::Unretained(this),
@@ skipping 148 matching lines @@
     // Append the whole bear1 file.
     EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(2)).Times(7);
     // Expect duration adjustment since actual duration differs slightly from
     // duration in the init segment.
     EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(2746)));
     AppendData(bear1->data(), bear1->data_size());
     // Last audio frame has timestamp 2721 and duration 24 (estimated from max
     // 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
     // media/test/data/bear-640x360-manifest.js and
     // media/test/data/bear-320x240-manifest.js which were
     // generated from media/test/data/bear-640x360.webm and
     // media/test/data/bear-320x240.webm respectively.
     EXPECT_CALL(*this, InitSegmentReceived());
     AppendData(bear2->data(), 4340);
 
     // Append a media segment that goes from [0.527000, 1.014000).
     EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(2));
     EXPECT_MEDIA_LOG(GeneratedSplice(20000, 527000));
     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);
     EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(23));
     EXPECT_MEDIA_LOG(GeneratedSplice(26000, 779000));
     AppendData(bear1->data() + 72737, 28183);
-    CheckExpectedRanges(kSourceId, "{ [0,2736) }");
+    CheckExpectedRanges("{ [0,2736) }");
 
     MarkEndOfStream(PIPELINE_OK);
     return true;
   }
 
   void ShutdownDemuxer() {
     if (demuxer_) {
       demuxer_->Shutdown();
       message_loop_.RunUntilIdle();
     }
@@ skipping 173 matching lines @@
     GenerateSingleStreamExpectedReads(
         timecode, block_count, DemuxerStream::VIDEO, kVideoBlockDuration);
   }
 
   scoped_ptr<Cluster> GenerateEmptyCluster(int timecode) {
     ClusterBuilder cb;
     cb.SetClusterTimecode(timecode);
     return cb.Finish();
   }
 
+  void CheckExpectedRangesForMediaSource(const std::string& expected) {
+    CheckExpectedRanges(demuxer_->GetBufferedRanges(), expected);
+  }
+
   void CheckExpectedRanges(const std::string& expected) {
     CheckExpectedRanges(kSourceId, expected);
+    CheckExpectedRangesForMediaSource(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);
   }
 
   void CheckExpectedRanges(DemuxerStream::Type type,
                            const std::string& expected) {
     ChunkDemuxerStream* stream =
         static_cast<ChunkDemuxerStream*>(demuxer_->GetStream(type));
     CheckExpectedRanges(stream->GetBufferedRanges(kDefaultDuration()),
                         expected);
   }
@@ skipping 371 matching lines @@
                        append_window_end_for_next_append_,
                        &timestamp_offset_map_[kSourceId],
                        init_segment_received_cb_);
 
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum, "46K 69K", 23),
       MuxedStreamInfo(kVideoTrackNum, "60K",
                       WebMClusterParser::kDefaultVideoBufferDurationInMs),
       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");
 
   ShutdownDemuxer();
 }
 
 TEST_F(ChunkDemuxerTest, InitSegmentSetsNeedRandomAccessPointFlag) {
   // Tests that non-key-frames following an init segment are allowed
   // and dropped, as expected if the initialization segment received
   // algorithm correctly sets the needs random access point flag to true for all
   // track buffers. Note that the first initialization segment is insufficient
   // to fully test this since needs random access point flag initializes to
   // true.
   CreateNewDemuxer();
   DemuxerStream* text_stream = NULL;
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
   ASSERT_TRUE(InitDemuxerWithEncryptionInfo(
       HAS_TEXT | HAS_AUDIO | HAS_VIDEO, false, false));
   DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(audio_stream && video_stream && text_stream);
 
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum, "23K",
                       WebMClusterParser::kDefaultAudioBufferDurationInMs),
       MuxedStreamInfo(kVideoTrackNum, "0 30K", 30),
       MuxedStreamInfo(kTextTrackNum, "25K 40K"));
-  CheckExpectedRanges(kSourceId, "{ [23,46) }");
+  CheckExpectedRanges("{ [23,46) }");
 
   EXPECT_CALL(*this, InitSegmentReceived());
   AppendInitSegment(HAS_TEXT | HAS_AUDIO | HAS_VIDEO);
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "46K 69K", 23),
                      MuxedStreamInfo(kVideoTrackNum, "60 90K", 30),
                      MuxedStreamInfo(kTextTrackNum, "80K 90K"));
   CheckExpectedRanges("{ [23,92) }");
 
   CheckExpectedBuffers(audio_stream, "23K 46K 69K");
   CheckExpectedBuffers(video_stream, "30K 90K");
@@ skipping 488 matching lines @@
 
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO | HAS_TEXT));
 
   AppendMuxedCluster(MuxedStreamInfo(kVideoTrackNum, "0K 33", 33),
                      MuxedStreamInfo(kAudioTrackNum, "0K 23K", 23));
 
   // 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.
   EXPECT_MEDIA_LOG(SkippingSpliceAtOrBefore(0, 0));
   EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(200)));
   AppendMuxedCluster(MuxedStreamInfo(kVideoTrackNum, "0K 33", 33),
                      MuxedStreamInfo(kAudioTrackNum, "0K 23K", 23),
                      MuxedStreamInfo(kTextTrackNum, "0K 100K"));
   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.
 TEST_F(ChunkDemuxerTest, AppendingInPieces) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK), true);
 
   ASSERT_EQ(AddId(), ChunkDemuxer::kOk);
 
@@ skipping 125 matching lines @@
 
   ExpectInitMediaLogs(HAS_AUDIO | HAS_VIDEO);
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(2));
   ASSERT_TRUE(ParseWebMFile("bear-320x240-altref.webm", buffer_timestamps,
                             base::TimeDelta::FromMilliseconds(2767)));
 }
 
 // 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));
 
   bool audio_read_done = false;
   bool video_read_done = false;
   ReadAudio(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(0),
                        &audio_read_done));
   ReadVideo(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(0),
@@ skipping 362 matching lines @@
   demuxer_->StartWaitingForSeek(seek_time);
   demuxer_->Seek(seek_time,
                  base::Bind(OnSeekDone_OKExpected, &seek_cb_was_called));
   message_loop_.RunUntilIdle();
 
   EXPECT_FALSE(seek_cb_was_called);
 
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(120)));
   MarkEndOfStream(PIPELINE_OK);
+  CheckExpectedRanges("{ [0,120) }");
   message_loop_.RunUntilIdle();
 
   EXPECT_TRUE(seek_cb_was_called);
 
   ShutdownDemuxer();
 }
 
 // Test that EndOfStream is ignored if coming during a pending seek
 // whose seek time is before some existing ranges.
 TEST_F(ChunkDemuxerTest, EndOfStreamDuringPendingSeek) {
@@ skipping 78 matching lines @@
 
   CheckExpectedRanges("{ [0,132) }");
 
   // Append a disjoint cluster to check for two separate ranges.
   AppendCluster(GenerateSingleStreamCluster(
       200, 299, kVideoTrackNum, kVideoBlockDuration));
 
   CheckExpectedRanges("{ [0,132) [200,299) }");
 }
 
+TEST_F(ChunkDemuxerTest, GetBufferedRanges_SeparateStreams) {
+  std::string audio_id = "audio1";
+  std::string video_id = "video1";
+  ASSERT_TRUE(InitDemuxerAudioAndVideoSources(audio_id, video_id));
+
+  // Append audio and video data into separate source ids.
+
+  // Audio block: 0 -> 23
+  // Video block: 0 -> 33
+  // Buffered Range: 0 -> 23
+  // Audio block duration is smaller than video block duration,
+  // so the buffered ranges should correspond to the audio blocks.
+  AppendCluster(audio_id,
+                GenerateSingleStreamCluster(0, 23, kAudioTrackNum, 23));
+  AppendCluster(video_id,
+                GenerateSingleStreamCluster(0, 33, kVideoTrackNum, 33));
+  CheckExpectedRanges(DemuxerStream::AUDIO, "{ [0,23) }");
+  CheckExpectedRanges(DemuxerStream::VIDEO, "{ [0,33) }");
+  CheckExpectedRangesForMediaSource("{ [0,23) }");
+
+  // Audio blocks: 300 -> 400
+  // Video blocks: 320 -> 420
+  // Buffered Range: 320 -> 400  (jagged start and end across SourceBuffers)
+  AppendCluster(audio_id,
+                GenerateSingleStreamCluster(300, 400, kAudioTrackNum, 50));
+  AppendCluster(video_id,
+                GenerateSingleStreamCluster(320, 420, kVideoTrackNum, 50));
+  CheckExpectedRanges(DemuxerStream::AUDIO, "{ [0,23) [300,400) }");
+  CheckExpectedRanges(DemuxerStream::VIDEO, "{ [0,33) [320,420) }");
+  CheckExpectedRangesForMediaSource("{ [0,23) [320,400) }");
+
+  // Audio block: 520 -> 590
+  // Video block: 500 -> 570
+  // Buffered Range: 520 -> 570  (jagged start and end across SourceBuffers)
+  AppendCluster(audio_id,
+                GenerateSingleStreamCluster(520, 590, kAudioTrackNum, 70));
+  AppendCluster(video_id,
+                GenerateSingleStreamCluster(500, 570, kVideoTrackNum, 70));
+  CheckExpectedRanges(DemuxerStream::AUDIO, "{ [0,23) [300,400) [520,590) }");
+  CheckExpectedRanges(DemuxerStream::VIDEO, "{ [0,33) [320,420) [500,570) }");
+  CheckExpectedRangesForMediaSource("{ [0,23) [320,400) [520,570) }");
+
+  // Audio block: 720 -> 750
+  // Video block: 700 -> 770
+  // Buffered Range: 720 -> 750  (complete overlap of audio)
+  AppendCluster(audio_id,
+                GenerateSingleStreamCluster(720, 750, kAudioTrackNum, 30));
+  AppendCluster(video_id,
+                GenerateSingleStreamCluster(700, 770, kVideoTrackNum, 70));
+  CheckExpectedRanges(DemuxerStream::AUDIO,
+                      "{ [0,23) [300,400) [520,590) [720,750) }");
+  CheckExpectedRanges(DemuxerStream::VIDEO,
+                      "{ [0,33) [320,420) [500,570) [700,770) }");
+  CheckExpectedRangesForMediaSource("{ [0,23) [320,400) [520,570) [720,750) }");
+
+  // Audio block: 900 -> 970
+  // Video block: 920 -> 950
+  // Buffered Range: 920 -> 950  (complete overlap of video)
+  AppendCluster(audio_id,
+                GenerateSingleStreamCluster(900, 970, kAudioTrackNum, 70));
+  AppendCluster(video_id,
+                GenerateSingleStreamCluster(920, 950, kVideoTrackNum, 30));
+  CheckExpectedRanges(DemuxerStream::AUDIO,
+                      "{ [0,23) [300,400) [520,590) [720,750) [900,970) }");
+  CheckExpectedRanges(DemuxerStream::VIDEO,
+                      "{ [0,33) [320,420) [500,570) [700,770) [920,950) }");
+  CheckExpectedRangesForMediaSource(
+      "{ [0,23) [320,400) [520,570) [720,750) [920,950) }");
+
+  // Appending within buffered range should not affect buffered ranges.
+  EXPECT_MEDIA_LOG(GeneratedSplice(40000, 930000));
+  AppendCluster(audio_id,
+                GenerateSingleStreamCluster(930, 950, kAudioTrackNum, 20));
+  AppendCluster(video_id,
+                GenerateSingleStreamCluster(930, 950, kVideoTrackNum, 20));
+  CheckExpectedRanges(DemuxerStream::AUDIO,
+                      "{ [0,23) [300,400) [520,590) [720,750) [900,970) }");
+  CheckExpectedRanges(DemuxerStream::VIDEO,
+                      "{ [0,33) [320,420) [500,570) [700,770) [920,950) }");
+  CheckExpectedRangesForMediaSource(
+      "{ [0,23) [320,400) [520,570) [720,750) [920,950) }");
+}
+
 TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioVideo) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
-  // Audio: 0 -> 23
-  // Video: 0 -> 33
+  // Audio block: 0 -> 23
+  // Video block: 0 -> 33
   // 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
-  // Buffered Range: 320 -> 400  (end overlap)
-  AppendCluster(GenerateSingleStreamCluster(300, 400, kAudioTrackNum, 50));
-  AppendCluster(GenerateSingleStreamCluster(320, 420, kVideoTrackNum, 50));
+  // Audio blocks: 300 -> 400
+  // Video blocks: 320 -> 420
+  // 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));
+  // Audio block: 520 -> 590
+  // Video block: 500 -> 570
+  // 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
+  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));
+  // Audio block: 720 -> 750
+  // Video block: 700 -> 770
+  // 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
+  AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "720D30K"),
+                     MuxedStreamInfo(kVideoTrackNum, "700D70K"));
 
-  CheckExpectedRanges("{ [0,23) [320,400) [520,570) [720,750) }");
+  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));
+  // Audio block: 900 -> 970
+  // Video block: 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("{ [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) }");
 
   // Appending within buffered range should not affect buffered ranges.
   EXPECT_MEDIA_LOG(GeneratedSplice(40000, 930000));
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "930D20K"),
                      MuxedStreamInfo(kVideoTrackNum, "930D20K"));
-  CheckExpectedRanges("{ [0,23) [320,400) [520,570) [720,750) [920,950) }");
-
-  // 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) {
   EXPECT_CALL(host_, AddTextStream(_, _));
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO | HAS_TEXT));
 
   // Append audio & video data
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "0K 23K", 23),
                      MuxedStreamInfo(kVideoTrackNum, "0K 33", 33));
 
@@ skipping 124 matching lines @@
 
   // Should not be able to fulfill a seek to 0.
   base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(0);
   demuxer_->StartWaitingForSeek(seek_time);
   demuxer_->Seek(seek_time,
                  NewExpectedStatusCB(PIPELINE_ERROR_ABORT));
   ExpectRead(DemuxerStream::AUDIO, 0);
   ExpectEndOfStream(DemuxerStream::VIDEO);
 }
 
-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);
-}
-
 TEST_F(ChunkDemuxerTest, CodecPrefixMatching) {
   ChunkDemuxer::Status expected = ChunkDemuxer::kNotSupported;
 
 #if defined(USE_PROPRIETARY_CODECS)
   expected = ChunkDemuxer::kOk;
 #endif
 
   std::vector<std::string> codecs;
   codecs.push_back("avc1.4D4041");
 
@@ skipping 402 matching lines @@
                              append_window_start_for_next_append_,
                              append_window_end_for_next_append_,
                              &timestamp_offset_map_[kSourceId]);
 }
 
 #endif
 #endif
 
 TEST_F(ChunkDemuxerTest, WebMIsParsingMediaSegmentDetection) {
   const uint8_t kBuffer[] = {
-      0x1F, 0x43, 0xB6, 0x75, 0x83,  // CLUSTER (size = 3)
-      0xE7, 0x81, 0x01,              // Cluster TIMECODE (value = 1)
+      // CLUSTER (size = 10)
+      0x1F, 0x43, 0xB6, 0x75, 0x8A,
 
-      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,
-      0x8A,  // EBMLHEADER (size = 10, not fully appended)
+      // Cluster TIMECODE (value = 1)
+      0xE7, 0x81, 0x01,
+
+      // SIMPLEBLOCK (size = 5)
+      0xA3, 0x85,
+
+      // Audio Track Number
+      0x80 | (kAudioTrackNum & 0x7F),
+
+      // Timecode (relative to cluster) (value = 0)
+      0x00, 0x00,
+
+      // Keyframe flag
+      0x80,
+
+      // Fake block data
+      0x00,
+
+      // CLUSTER (size = unknown; really 10)
+      0x1F, 0x43, 0xB6, 0x75, 0xFF,
+
+      // Cluster TIMECODE (value = 2)
+      0xE7, 0x81, 0x02,
+
+      // SIMPLEBLOCK (size = 5)
+      0xA3, 0x85,
+
+      // Audio Track Number
+      0x80 | (kAudioTrackNum & 0x7F),
+
+      // Timecode (relative to cluster) (value = 0)
+      0x00, 0x00,
+
+      // Keyframe flag
+      0x80,
+
+      // Fake block data
+      0x00,
+
+      // EBMLHEADER (size = 10, not fully appended)
+      0x1A, 0x45, 0xDF, 0xA3, 0x8A,

[chcunningham, 2016/01/20 00:40:59]

Is this part needed?

[wolenetz, 2016/01/20 00:45:48]

Indeed it is. The termination of an "unknown"-sized WebM cluster is determined
by the presence of something like an EBMLHEADER (or another top-level tag). We
don't know a full EBMLHEADER is complete until we get the full header. Note the
transition in kExpectedReturnValues[], below, from true to false on the very
last byte.

   };
 
   // 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,
+      // First Cluster, explicit size
+      false, false, false, false, true, true, true, true, true, true, true,
+      true, true, true, false,
 
-    false, false, false, false, true,
-    true, true, true,
+      // Second Cluster, unknown size
+      false, false, false, false, true, true, true, true, true, true, true,
+      true, true, true, true,
 
-    true, true, true, true, false,
+      // EBMLHEADER
+      true, true, true, true, false,
   };
 
   static_assert(arraysize(kBuffer) == arraysize(kExpectedReturnValues),
       "test arrays out of sync");
   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));
+  EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(23)).Times(2);
+  EXPECT_MEDIA_LOG(GeneratedSplice(22000, 2000));
   for (size_t i = 0; i < sizeof(kBuffer); i++) {
     DVLOG(3) << "Appending and testing index " << i;
     AppendData(kBuffer + i, 1);
     bool expected_return_value = kExpectedReturnValues[i];
     EXPECT_EQ(expected_return_value,
               demuxer_->IsParsingMediaSegment(kSourceId));
   }
 }
 
 TEST_F(ChunkDemuxerTest, DurationChange) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   const int kStreamDuration = kDefaultDuration().InMilliseconds();
 
   // Add data leading up to the currently set duration.
   AppendCluster(GenerateCluster(kStreamDuration - kAudioBlockDuration,
                                 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
   // timestamp than the last audio block.
   const int kNewStreamDurationVideo = kStreamDuration + kVideoBlockDuration;
   EXPECT_CALL(host_, SetDuration(
       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.
   const int kFinalStreamDuration = kStreamDuration + kAudioBlockDuration * 3;
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(kFinalStreamDuration)));
   AppendCluster(GenerateCluster(kStreamDuration + kAudioBlockDuration,
                                 kStreamDuration + kVideoBlockDuration,
                                 3));
 
   // 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) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   ASSERT_TRUE(SetTimestampOffset(kSourceId, kDefaultDuration()));
   EXPECT_CALL(host_, SetDuration(
       kDefaultDuration() + base::TimeDelta::FromMilliseconds(
           kVideoBlockDuration * 2)));
   AppendCluster(GenerateCluster(0, 4));
 }
@@ skipping 39 matching lines @@
   message_loop_.RunUntilIdle();
 }
 
 // Verifies that signaling end of stream while stalled at a gap
 // boundary does not trigger end of stream buffers to be returned.
 TEST_F(ChunkDemuxerTest, EndOfStreamWhileWaitingForGapToBeFilled) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   AppendCluster(0, 10);
   AppendCluster(300, 10);
-  CheckExpectedRanges(kSourceId, "{ [0,132) [300,432) }");
+  CheckExpectedRanges("{ [0,132) [300,432) }");
 
   GenerateExpectedReads(0, 10);
 
   bool audio_read_done = false;
   bool video_read_done = false;
   ReadAudio(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(138),
                        &audio_read_done));
   ReadVideo(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(138),
                        &video_read_done));
 
   // Verify that the reads didn't complete
   EXPECT_FALSE(audio_read_done);
   EXPECT_FALSE(video_read_done);
 
   EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(438)));
   MarkEndOfStream(PIPELINE_OK);
 
   // Verify that the reads still haven't completed.
   EXPECT_FALSE(audio_read_done);
   EXPECT_FALSE(video_read_done);
 
   demuxer_->UnmarkEndOfStream();
 
   AppendCluster(138, 22);
 
   message_loop_.RunUntilIdle();
 
-  CheckExpectedRanges(kSourceId, "{ [0,435) }");
+  CheckExpectedRanges("{ [0,435) }");
 
   // Verify that the reads have completed.
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 
   // Read the rest of the buffers.
   GenerateExpectedReads(161, 171, 20);
 
   // Verify that reads block because the append cleared the end of stream state.
   audio_read_done = false;
@@ skipping 66 matching lines @@
   // Verify that the old data, and nothing more, has been garbage collected.
   CheckExpectedRanges(DemuxerStream::AUDIO, "{ [1000,1230) }");
   CheckExpectedRanges(DemuxerStream::VIDEO, "{ [1000,1165) }");
 }
 
 TEST_F(ChunkDemuxerTest, GCDuringSeek_SingleRange_SeekForward) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
   demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 10 * kBlockSize);
   // Append some data at position 1000ms
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 1000, 10);
-  CheckExpectedRanges(kSourceId, "{ [1000,1230) }");
+  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.
   base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(2000);
   Seek(seek_time);
   EXPECT_TRUE(demuxer_->EvictCodedFrames(kSourceId, seek_time, 5 * kBlockSize));
 
   // 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) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
   demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 10 * kBlockSize);
   // Append some data at position 1000ms
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 1000, 10);
-  CheckExpectedRanges(kSourceId, "{ [1000,1230) }");
+  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
   // evicted to make space for the upcoming append at seek target position.
   base::TimeDelta seek_time = base::TimeDelta();
   Seek(seek_time);
   EXPECT_TRUE(demuxer_->EvictCodedFrames(kSourceId, seek_time, 5 * kBlockSize));
 
   // 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) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
   demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 10 * kBlockSize);
   // 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.
   base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(3000);
   Seek(seek_time);
   EXPECT_TRUE(demuxer_->EvictCodedFrames(kSourceId, seek_time, 8 * kBlockSize));
 
   // 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) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
   demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 10 * kBlockSize);
   // 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
   // blocks worth of data in the first range and seek target position has no
   // data, so GC proceeds with trying to delete some frames from the back of
   // buffered ranges, that doesn't yield anything, since that's the most
   // recently appended data, so then GC starts removing data from the front of
   // the remaining buffered range (2000ms) to ensure we free up enough space for
   // the upcoming append and allow seek to proceed.
   base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(1500);
   Seek(seek_time);
   EXPECT_TRUE(demuxer_->EvictCodedFrames(kSourceId, seek_time, 8 * kBlockSize));
 
   // 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) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
   demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 10 * kBlockSize);
 
   // Append some data at position 2000ms first, then at 1000ms, so that the last
   // appended data position is in the first buffered range (that matters to the
   // 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
   // first range, since that is most recently appended data.
   base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(2030);
   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) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
   demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 10 * kBlockSize);
   // 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.
   base::TimeDelta seek_time = base::TimeDelta();
   Seek(seek_time);
   EXPECT_TRUE(demuxer_->EvictCodedFrames(kSourceId, seek_time, 8 * kBlockSize));
 
   // 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) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
 
   demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 5 * kBlockSize);
 
   base::TimeDelta seek_time1 = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta seek_time2 = base::TimeDelta::FromMilliseconds(500);
 
   // Initiate a seek to |seek_time1|.
   Seek(seek_time1);
 
   // 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);
 
   // 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));
 
   // Append more data and make sure that we preserve both the buffered range
   // around |seek_time2|, because that's the current playback position,
   // and the newly appended range, since this is the most recent append.
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 700, 5);
   EXPECT_FALSE(demuxer_->EvictCodedFrames(kSourceId, seek_time2, 0));
-  CheckExpectedRanges(kSourceId, "{ [500,615) [700,815) }");
+  CheckExpectedRanges("{ [500,615) [700,815) }");
 }
 
 TEST_F(ChunkDemuxerTest, GCKeepPlayhead) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
 
   demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 5 * kBlockSize);
 
   // Append data at the start that can be garbage collected:
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 0, 10);
-  CheckExpectedRanges(kSourceId, "{ [0,230) }");
+  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.
   base::TimeDelta seek_time3 = base::TimeDelta::FromMilliseconds(23*6);
   Seek(seek_time3);
   EXPECT_TRUE(demuxer_->EvictCodedFrames(kSourceId, seek_time3, 0));
   // 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) {
   ASSERT_TRUE(InitDemuxer(HAS_VIDEO));
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
 
   // Set the append window to [50,280).
   append_window_start_for_next_append_ = base::TimeDelta::FromMilliseconds(50);
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(280);
 
   // Append a cluster that starts before and ends after the append window.
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(30));
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum,
                             "0K 30 60 90 120K 150 180 210 240K 270 300 330K");
 
   // 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).
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(650);
 
   // Append more data and verify that adding buffers start at the next
   // key frame.
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(30));
   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) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::AUDIO);
 
   // Set the append window to [50,280).
   append_window_start_for_next_append_ = base::TimeDelta::FromMilliseconds(50);
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(280);
 
   // Append a cluster that starts before and ends after the append window.
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(30));
   AppendSingleStreamCluster(
       kSourceId, kAudioTrackNum,
       "0K 30K 60K 90K 120K 150K 180K 210K 240K 270K 300K 330K");
 
   // Verify that frames that end 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.
   //
   // 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.
   CheckExpectedBuffers(stream, "50KP 50K 60K 90K 120K 150K 180K 210K 240K");
 
   // Extend the append window to [50,650).
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(650);
 
   // Append more data and verify that a new range is created.
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(30));
   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) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
 
   // Set the append window to [10,20).
   append_window_start_for_next_append_ = base::TimeDelta::FromMilliseconds(10);
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(20);
 
   // Append a cluster that starts before and ends after the append window.
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(
       WebMClusterParser::kDefaultAudioBufferDurationInMs));
   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) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_,
       CreateInitDoneCB(base::TimeDelta::FromMilliseconds(2744), PIPELINE_OK),
       true);
   ASSERT_EQ(ChunkDemuxer::kOk, AddId(kSourceId, HAS_AUDIO));
 
@@ skipping 30 matching lines @@
   const base::TimeDelta duration_1 = base::TimeDelta::FromMilliseconds(2746);
   append_window_start_for_next_append_ = duration_1;
 
   // Read a WebM file into memory and append the data.
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-320x240-audio-only.webm");
   ExpectInitMediaLogs(HAS_AUDIO);
   EXPECT_CALL(*this, InitSegmentReceived());
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(2));
   AppendDataInPieces(buffer->data(), buffer->data_size(), 512);
-  CheckExpectedRanges(kSourceId, "{ }");
+  CheckExpectedRanges("{ }");
 
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   AudioDecoderConfig config_1 = stream->audio_decoder_config();
 
   // Read a second WebM with a different config in and append the data.
   scoped_refptr<DecoderBuffer> buffer2 =
       ReadTestDataFile("bear-320x240-audio-only-48khz.webm");
   EXPECT_CALL(*this, InitSegmentReceived());
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(21));
   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);
   ASSERT_FALSE(config_1.Matches(stream->audio_decoder_config()));
   CheckExpectedBuffers(stream, "2746K 2767K 2789K 2810K");
 }
 
 TEST_F(ChunkDemuxerTest, AppendWindow_Text) {
   DemuxerStream* text_stream = NULL;
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
   ASSERT_TRUE(InitDemuxer(HAS_VIDEO | HAS_TEXT));
   DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
 
   // Set the append window to [20,280).
   append_window_start_for_next_append_ = base::TimeDelta::FromMilliseconds(20);
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(280);
 
   // Append a cluster that starts before and ends after the append
   // window.
   AppendMuxedCluster(
       MuxedStreamInfo(kVideoTrackNum,
                       "0K 30 60 90 120K 150 180 210 240K 270 300 330K", 30),
       MuxedStreamInfo(kTextTrackNum, "0K 100K 200K 300K"));
 
   // 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");
 
   // Extend the append window to [20,650).
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(650);
 
   // Append more data and verify that a new range is created.
   AppendMuxedCluster(
       MuxedStreamInfo(kVideoTrackNum,
                       "360 390 420K 450 480 510 540K 570 600 630K", 30),
@@ skipping 31 matching lines @@
 
   CheckExpectedBuffers(audio_stream, "0K 20K 40K 60K 80K 100K 120K 140K");
   CheckExpectedBuffers(video_stream, "0K 30 60 90 120K 150 180");
   CheckExpectedBuffers(text_stream, "0K 100K 200K");
 
   // Remove the buffers that were added.
   demuxer_->Remove(kSourceId, base::TimeDelta(),
                    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.
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum, "1K 21K 41K 61K 81K 101K 121K 141K", 20),
       MuxedStreamInfo(kVideoTrackNum, "1K 31 61 91 121K 151 181", 30),
       MuxedStreamInfo(kTextTrackNum, "1K 101K 201K"));
 
   Seek(base::TimeDelta());
   CheckExpectedBuffers(audio_stream, "1K 21K 41K 61K 81K 101K 121K 141K");
   CheckExpectedBuffers(video_stream, "1K 31 61 91 121K 151 181");
   CheckExpectedBuffers(text_stream, "1K 101K 201K");
 }
 
 TEST_F(ChunkDemuxerTest, Remove_StartAtDuration) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
   DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
 
   // Set the duration to something small so that the append that
   // follows updates the duration to reflect the end of the appended data.
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(1)));
   demuxer_->SetDuration(0.001);
 
   EXPECT_CALL(host_, SetDuration(
       base::TimeDelta::FromMilliseconds(160)));
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum,
                             "0K 20K 40K 60K 80K 100K 120K 140D20K");
 
-  CheckExpectedRanges(kSourceId, "{ [0,160) }");
+  CheckExpectedRanges("{ [0,160) }");
   CheckExpectedBuffers(audio_stream, "0K 20K 40K 60K 80K 100K 120K 140K");
 
   demuxer_->Remove(kSourceId,
                    base::TimeDelta::FromSecondsD(demuxer_->GetDuration()),
                    kInfiniteDuration());
 
   Seek(base::TimeDelta());
-  CheckExpectedRanges(kSourceId, "{ [0,160) }");
+  CheckExpectedRanges("{ [0,160) }");
   CheckExpectedBuffers(audio_stream, "0K 20K 40K 60K 80K 100K 120K 140K");
 }
 
 // Verifies that a Seek() will complete without text cues for
 // the seek point and will return cues after the seek position
 // when they are eventually appended.
 TEST_F(ChunkDemuxerTest, SeekCompletesWithoutTextCues) {
   DemuxerStream* text_stream = NULL;
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
@@ skipping 47 matching lines @@
 
   // Verify that audio & video streams continue to return expected values.
   CheckExpectedBuffers(audio_stream, "160K 180K");
   CheckExpectedBuffers(video_stream, "180 210");
 }
 
 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) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   // Add two clusters separated by Cues in a single Append() call.
   scoped_ptr<Cluster> cluster = GenerateCluster(0, 0, 4, true);
   std::vector<uint8_t> data(cluster->data(), cluster->data() + cluster->size());
   data.insert(data.end(), kCuesHeader, kCuesHeader + sizeof(kCuesHeader));
   cluster = GenerateCluster(46, 66, 5, true);
   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) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   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) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 10 * kBlockSize);
   demuxer_->SetMemoryLimits(DemuxerStream::VIDEO, 15 * kBlockSize);
   DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
 
   const char* kAudioStreamInfo = "0K 40K 80K 120K 160K 200K 240K 280K";
@@ skipping 32 matching lines @@
   // Given these numbers MSE GC will remove just one audio block (since current
   // audio size is 80 bytes, new data is 28 bytes, we need to remove just one 10
   // byte block to stay under 100 bytes memory limit after append
   // 80 - 10 + 28 = 98).
   // For video stream 150 + 52 = 202. Video limit is 150 bytes. We need to
   // remove at least 6 blocks to stay under limit.
   CheckExpectedBuffers(audio_stream, "40K 80K 120K 160K 200K 240K 280K");
   CheckExpectedBuffers(video_stream, "60K 70 80K 90 100K 110 120K 130 140K");
 }
 
+TEST_F(ChunkDemuxerTest, SegmentMissingAudioFrame_AudioOnly) {
+  ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
+  EXPECT_MEDIA_LOG(SegmentMissingFrames("audio"));
+  AppendCluster(GenerateEmptyCluster(0));
+}
+
+TEST_F(ChunkDemuxerTest, SegmentMissingVideoFrame_VideoOnly) {
+  ASSERT_TRUE(InitDemuxer(HAS_VIDEO));
+  EXPECT_MEDIA_LOG(SegmentMissingFrames("video"));
+  AppendCluster(GenerateEmptyCluster(0));
+}
+
+TEST_F(ChunkDemuxerTest, SegmentMissingAudioFrame_AudioVideo) {
+  ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
+  EXPECT_MEDIA_LOG(SegmentMissingFrames("audio"));
+  AppendSingleStreamCluster(kSourceId, kVideoTrackNum, 0, 10);
+}
+
+TEST_F(ChunkDemuxerTest, SegmentMissingVideoFrame_AudioVideo) {
+  ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
+  EXPECT_MEDIA_LOG(SegmentMissingFrames("video"));
+  AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 0, 10);
+}
+
+TEST_F(ChunkDemuxerTest, SegmentMissingAudioVideoFrames) {
+  ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
+  EXPECT_MEDIA_LOG(SegmentMissingFrames("audio or video"));
+  AppendCluster(GenerateEmptyCluster(0));
+}
+
 }  // namespace media