Fix WebMStreamParser to continue parsing after a cluster end

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 <algorithm>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
@@ skipping 655 matching lines @@
     const uint8* data =
         (flags & kWebMFlagKeyframe) != 0 ? kVP8Keyframe : kVP8Interframe;
     int size = (flags & kWebMFlagKeyframe) != 0 ? sizeof(kVP8Keyframe) :
         sizeof(kVP8Interframe);
     cb->AddBlockGroup(track_num, timecode, duration, flags, data, size);
   }
 
   scoped_ptr<Cluster> GenerateCluster(int first_audio_timecode,
                                       int first_video_timecode,
                                       int block_count) {
+    return GenerateCluster(first_audio_timecode, first_video_timecode,
+                           block_count, false);
+  }
+  scoped_ptr<Cluster> GenerateCluster(int first_audio_timecode,
+                                      int first_video_timecode,
+                                      int block_count,
+                                      bool unknown_size) {
     CHECK_GT(block_count, 0);
 
     int size = 10;
     scoped_ptr<uint8[]> data(new uint8[size]);
 
     ClusterBuilder cb;
     cb.SetClusterTimecode(std::min(first_audio_timecode, first_video_timecode));
 
     if (block_count == 1) {
       cb.AddBlockGroup(kAudioTrackNum, first_audio_timecode,
@@ skipping 29 matching lines @@
                        kWebMFlagKeyframe, data.get(), size);
       AddVideoBlockGroup(&cb, kVideoTrackNum, video_timecode,
                          kVideoBlockDuration, video_flag);
     } else {
       AddVideoBlockGroup(&cb, kVideoTrackNum, video_timecode,
                          kVideoBlockDuration, video_flag);
       cb.AddBlockGroup(kAudioTrackNum, audio_timecode, kAudioBlockDuration,
                        kWebMFlagKeyframe, data.get(), size);
     }
 
-    return cb.Finish();
+    return unknown_size ? cb.FinishWithUnknownSize() : cb.Finish();
   }
 
   scoped_ptr<Cluster> GenerateSingleStreamCluster(int timecode,
                                                   int end_timecode,
                                                   int track_number,
                                                   int block_duration) {
     CHECK_GT(end_timecode, timecode);
 
     std::vector<uint8> data(kBlockSize);
 
@@ skipping 2150 matching lines @@
 
   ASSERT_EQ(range_before_abort.size(), 1u);
   ASSERT_EQ(range_after_abort.size(), 1u);
   EXPECT_EQ(range_after_abort.start(0), range_before_abort.start(0));
   EXPECT_GT(range_after_abort.end(0), range_before_abort.end(0));
 }
 #endif
 #endif
 
 TEST_P(ChunkDemuxerTest, WebMIsParsingMediaSegmentDetection) {
-  // TODO(wolenetz): Also test 'unknown' sized clusters.
-  // See http://crbug.com/335676.
   const uint8 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, 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, false,
   };
 
   COMPILE_ASSERT(arraysize(kBuffer) == arraysize(kExpectedReturnValues),
       test_arrays_out_of_sync);
   COMPILE_ASSERT(arraysize(kBuffer) == sizeof(kBuffer), not_one_byte_per_index);
 
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   for (size_t i = 0; i < sizeof(kBuffer); i++) {
     DVLOG(3) << "Appending and testing index " << i;
@@ skipping 529 matching lines @@
 
   // NOTE: we start at 175 here because the buffer at 125 was returned
   // to the pending read initiated above.
   CheckExpectedBuffers(text_stream, "175 225");
 
   // Verify that audio & video streams continue to return expected values.
   CheckExpectedBuffers(audio_stream, "160 180");
   CheckExpectedBuffers(video_stream, "180 210");
 }
 
+TEST_P(ChunkDemuxerTest, ClusterWithUnknownSize) {
+  ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
+
+  AppendCluster(GenerateCluster(0, 0, 4, true));
+  CheckExpectedRanges(kSourceId, "{ [0,46) }");
+
+  // A new cluster indicates end of the previous cluster with unknown size.
+  AppendCluster(GenerateCluster(46, 66, 5, true));
+  CheckExpectedRanges(kSourceId, "{ [0,115) }");
+}
+
 // Generate two sets of tests: one using FrameProcessor, and one using
 // LegacyFrameProcessor.
 INSTANTIATE_TEST_CASE_P(NewFrameProcessor, ChunkDemuxerTest, Values(false));
 INSTANTIATE_TEST_CASE_P(LegacyFrameProcessor, ChunkDemuxerTest, Values(true));
 
 }  // namespace media