Update WebMClusterParser to compute durations for all StreamParserBuffers.

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 "base/bind.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_demuxer_host.h"
 #include "media/base/test_data_util.h"
 #include "media/filters/chunk_demuxer.h"
@@ skipping 21 matching lines @@
 // The size of TrackEntry element in test file "webm_vp8_track_entry" starts at
 // index 1 and spans 8 bytes.
 static const int kVideoTrackSizeOffset = 1;
 static const int kVideoTrackSizeWidth = 8;
 static const int kVideoTrackEntryHeaderSize = kVideoTrackSizeOffset +
                                               kVideoTrackSizeWidth;
 
 static const int kVideoTrackNum = 1;
 static const int kAudioTrackNum = 2;
 
+static const int kAudioBlockDuration = 23;
+static const int kVideoBlockDuration = 33;
+
 static const char* kSourceId = "SourceId";
 
 base::TimeDelta kDefaultDuration() {
   return base::TimeDelta::FromMilliseconds(201224);
 }
 
 // Write an integer into buffer in the form of vint that spans 8 bytes.
 // The data pointed by |buffer| should be at least 8 bytes long.
 // |number| should be in the range 0 <= number < 0x00FFFFFFFFFFFFFF.
 static void WriteInt64(uint8* buffer, int64 number) {
   DCHECK(number >= 0 && number < GG_LONGLONG(0x00FFFFFFFFFFFFFF));
   buffer[0] = 0x01;
   int64 tmp = number;
   for (int i = 7; i > 0; i--) {
     buffer[i] = tmp & 0xff;
     tmp >>= 8;
   }
 }
 
 MATCHER_P(HasTimestamp, timestamp_in_ms, "") {
-  return !arg->IsEndOfStream() &&
+  return arg && !arg->IsEndOfStream() &&
       arg->GetTimestamp().InMilliseconds() == timestamp_in_ms;
 }
 
 static void OnReadDone(const base::TimeDelta& expected_time,
                        bool* called,
                        const scoped_refptr<Buffer>& buffer) {
   EXPECT_EQ(expected_time, buffer->GetTimestamp());
   *called = true;
 }
 
@@ skipping 97 matching lines @@
   }
 
   ChunkDemuxer::Status AddId() {
     std::vector<std::string> codecs(2);
     codecs[0] = "vp8";
     codecs[1] = "vorbis";
     return demuxer_->AddId(kSourceId, "video/webm", codecs);
   }
 
   bool AppendData(const uint8* data, size_t length) {
+    if (!length) {
+      LOG(ERROR) << "Test code tried to append a zero length buffer!";

[scherkus (not reviewing), 2012/05/17 02:45:46]

NOTREACHED() / LOG(FATAL) / CHECK() instead?

[acolwell GONE FROM CHROMIUM, 2012/05/17 18:28:51]

Done.

+      return false;
+    }
+
     EXPECT_CALL(host_, SetBufferedBytes(_)).Times(AnyNumber());
     EXPECT_CALL(host_, SetNetworkActivity(true))
         .Times(AnyNumber());
     return demuxer_->AppendData(kSourceId, data, length);
   }
 
   bool AppendDataInPieces(const uint8* data, size_t length) {
     return AppendDataInPieces(data, length, 7);
   }
 
@@ skipping 56 matching lines @@
       EXPECT_CALL(*client_, DemuxerClosed());
       demuxer_->Shutdown();
     }
   }
 
   void AddSimpleBlock(ClusterBuilder* cb, int track_num, int64 timecode) {
     uint8 data[] = { 0x00 };
     cb->AddSimpleBlock(track_num, timecode, 0, data, sizeof(data));
   }
 
-  void AddSimpleBlock(ClusterBuilder* cb, int track_num, int64 timecode,
-                      int size) {
+  scoped_ptr<Cluster> GenerateCluster(int timecode, int block_count) {
+    CHECK_GT(block_count, 0);
+
+    int size = 10;
     scoped_array<uint8> data(new uint8[size]);
-    cb->AddSimpleBlock(track_num, timecode, 0, data.get(), size);
+
+    ClusterBuilder cb;
+    cb.SetClusterTimecode(timecode);
+    int audio_timecode = timecode;
+    int video_timecode = timecode + 1;
+
+    if (block_count == 1) {
+      cb.AddBlockGroup(kAudioTrackNum, audio_timecode, kAudioBlockDuration, 0,
+                       data.get(), size);
+      return cb.Finish();
+    }
+
+    // Create simple blocks for everything except the last 2 blocks.
+    for (int i = 0; i < block_count - 2; i++) {
+      if (audio_timecode <= video_timecode) {
+        cb.AddSimpleBlock(kAudioTrackNum, audio_timecode, 0, data.get(), size);
+        audio_timecode += kAudioBlockDuration;
+        continue;
+      }
+
+      cb.AddSimpleBlock(kVideoTrackNum, video_timecode, 0, data.get(), size);
+      video_timecode += kVideoBlockDuration;
+    }
+
+    // Make the last 2 blocks BlockGroups so that they don't get delayed by the
+    // block duration calculation logic.
+    if (audio_timecode <= video_timecode) {
+      cb.AddBlockGroup(kAudioTrackNum, audio_timecode, kAudioBlockDuration, 0,
+                       data.get(), size);
+      cb.AddBlockGroup(kVideoTrackNum, video_timecode, kVideoBlockDuration, 0,
+                       data.get(), size);
+    } else {
+      cb.AddBlockGroup(kVideoTrackNum, video_timecode, kVideoBlockDuration, 0,
+                       data.get(), size);
+      cb.AddBlockGroup(kAudioTrackNum, audio_timecode, kAudioBlockDuration, 0,
+                       data.get(), size);
+    }
+
+    return cb.Finish();
+  }
+
+  void GenerateExpectedReads(int timecode, int block_count,
+                             DemuxerStream* audio,
+                             DemuxerStream* video) {
+    CHECK_GT(block_count, 0);
+    int audio_timecode = timecode;
+    int video_timecode = timecode + 1;
+
+    if (block_count == 1) {
+      ExpectRead(audio, audio_timecode);
+      return;
+    }
+
+    for (int i = 0; i < block_count; i++) {
+      if (audio_timecode <= video_timecode) {
+        ExpectRead(audio, audio_timecode);
+        audio_timecode += kAudioBlockDuration;
+        continue;
+      }
+
+      ExpectRead(video, video_timecode);
+      video_timecode += kVideoBlockDuration;
+    }
   }
 
   MOCK_METHOD1(ReadDone, void(const scoped_refptr<Buffer>&));
 
   void ExpectRead(DemuxerStream* stream, int64 timestamp_in_ms) {
     EXPECT_CALL(*this, ReadDone(HasTimestamp(timestamp_in_ms)));
     stream->Read(base::Bind(&ChunkDemuxerTest::ReadDone,
                             base::Unretained(this)));
   }
 
@@ skipping 139 matching lines @@
 
   InSequence s;
 
   EXPECT_CALL(*this, Checkpoint(1));
 
   demuxer_->Seek(base::TimeDelta::FromSeconds(0),
                  NewExpectedStatusCB(PIPELINE_OK));
 
   EXPECT_CALL(*this, Checkpoint(2));
 
-  ClusterBuilder cb;
-  cb.SetClusterTimecode(0);
-  AddSimpleBlock(&cb, kVideoTrackNum, 0);
-  scoped_ptr<Cluster> cluster(cb.Finish());
+  scoped_ptr<Cluster> cluster(GenerateCluster(0, 4));
 
   Checkpoint(1);
 
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 
   Checkpoint(2);
 }
 
 // Test the case where a Seek() is requested while the parser
 // is in the middle of cluster. This is to verify that the parser
 // resets itself on seek and is in the right state when data from
 // the new seek point arrives.
 TEST_F(ChunkDemuxerTest, TestSeekWhileParsingCluster) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
 
   InSequence s;
 
-  ClusterBuilder cb;
-  cb.SetClusterTimecode(0);
-  AddSimpleBlock(&cb, kAudioTrackNum, 1);
-  AddSimpleBlock(&cb, kVideoTrackNum, 2);
-  AddSimpleBlock(&cb, kAudioTrackNum, 10);
-  AddSimpleBlock(&cb, kVideoTrackNum, 20);
-  scoped_ptr<Cluster> cluster_a(cb.Finish());
-
-  cb.SetClusterTimecode(5000);
-  AddSimpleBlock(&cb, kAudioTrackNum, 5000);
-  AddSimpleBlock(&cb, kVideoTrackNum, 5005);
-  AddSimpleBlock(&cb, kAudioTrackNum, 5007);
-  AddSimpleBlock(&cb, kVideoTrackNum, 5035);
-  scoped_ptr<Cluster> cluster_b(cb.Finish());
+  scoped_ptr<Cluster> cluster_a(GenerateCluster(0, 6));
+  scoped_ptr<Cluster> cluster_b(GenerateCluster(5000, 6));
 
   // Append all but the last byte so that everything but
   // the last block can be parsed.
   ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size() - 1));
 
-  ExpectRead(audio, 1);
-  ExpectRead(video, 2);
-  ExpectRead(audio, 10);
+  ExpectRead(audio, 0);
+  ExpectRead(video, 1);
+  ExpectRead(audio, kAudioBlockDuration);
+  // Note: We skip trying to read a video buffer here because computing
+  // the duration for this block relies on successfully parsing the last block
+  // in the cluster the cluster.
+  ExpectRead(audio, 2 * kAudioBlockDuration);
 
   demuxer_->FlushData();
   demuxer_->Seek(base::TimeDelta::FromSeconds(5),
                  NewExpectedStatusCB(PIPELINE_OK));
 
 
   // Append the new cluster and verify that only the blocks
   // in the new cluster are returned.
   ASSERT_TRUE(AppendData(cluster_b->data(), cluster_b->size()));
-  ExpectRead(audio, 5000);
-  ExpectRead(video, 5005);
-  ExpectRead(audio, 5007);
-  ExpectRead(video, 5035);
+  GenerateExpectedReads(5000, 6, audio, video);
 }
 
 // Test the case where AppendData() is called before Init().
 TEST_F(ChunkDemuxerTest, TestAppendDataBeforeInit) {
   scoped_array<uint8> info_tracks;
   int info_tracks_size = 0;
   CreateInfoTracks(true, true, false, &info_tracks, &info_tracks_size);
 
   EXPECT_FALSE(demuxer_->AppendData(kSourceId, info_tracks.get(),
                                     info_tracks_size));
 }
 
 // Make sure Read() callbacks are dispatched with the proper data.
 TEST_F(ChunkDemuxerTest, TestRead) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
 
   bool audio_read_done = false;
   bool video_read_done = false;
   audio->Read(base::Bind(&OnReadDone,
-                         base::TimeDelta::FromMilliseconds(32),
+                         base::TimeDelta::FromMilliseconds(0),
                          &audio_read_done));
 
   video->Read(base::Bind(&OnReadDone,
-                         base::TimeDelta::FromMilliseconds(123),
+                         base::TimeDelta::FromMilliseconds(1),
                          &video_read_done));
 
-  ClusterBuilder cb;
-  cb.SetClusterTimecode(0);
-  AddSimpleBlock(&cb, kAudioTrackNum, 32);
-  AddSimpleBlock(&cb, kVideoTrackNum, 123);
-  scoped_ptr<Cluster> cluster(cb.Finish());
+  scoped_ptr<Cluster> cluster(GenerateCluster(0, 4));
 
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 }
 
 TEST_F(ChunkDemuxerTest, TestOutOfOrderClusters) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
-  ClusterBuilder cb;
-
-  cb.SetClusterTimecode(10);
-  AddSimpleBlock(&cb, kAudioTrackNum, 10);
-  AddSimpleBlock(&cb, kVideoTrackNum, 10);
-  AddSimpleBlock(&cb, kAudioTrackNum, 33);
-  AddSimpleBlock(&cb, kVideoTrackNum, 43);
-  scoped_ptr<Cluster> cluster_a(cb.Finish());
+  scoped_ptr<Cluster> cluster_a(GenerateCluster(10, 4));
 
   ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size()));
 
   // Cluster B starts before cluster_a and has data
   // that overlaps.
-  cb.SetClusterTimecode(5);
-  AddSimpleBlock(&cb, kAudioTrackNum, 5);
-  AddSimpleBlock(&cb, kVideoTrackNum, 7);
-  AddSimpleBlock(&cb, kAudioTrackNum, 28);
-  AddSimpleBlock(&cb, kVideoTrackNum, 40);
-  scoped_ptr<Cluster> cluster_b(cb.Finish());
+  scoped_ptr<Cluster> cluster_b(GenerateCluster(5, 4));
 
   // Make sure that AppendData() fails because this cluster data
   // is before previous data.
   EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   ASSERT_TRUE(AppendData(cluster_b->data(), cluster_b->size()));
 
   // Verify that AppendData() doesn't accept more data now.
-  cb.SetClusterTimecode(45);
-  AddSimpleBlock(&cb, kAudioTrackNum, 45);
-  AddSimpleBlock(&cb, kVideoTrackNum, 45);
-  scoped_ptr<Cluster> cluster_c(cb.Finish());
+  scoped_ptr<Cluster> cluster_c(GenerateCluster(45, 2));
   EXPECT_FALSE(demuxer_->AppendData(kSourceId, cluster_c->data(),
                                     cluster_c->size()));
 }
 
 TEST_F(ChunkDemuxerTest, TestNonMonotonicButAboveClusterTimecode) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
   ClusterBuilder cb;
 
   // Test the case where block timecodes are not monotonically
   // increasing but stay above the cluster timecode.
   cb.SetClusterTimecode(5);
   AddSimpleBlock(&cb, kAudioTrackNum, 5);
   AddSimpleBlock(&cb, kVideoTrackNum, 10);
   AddSimpleBlock(&cb, kAudioTrackNum, 7);
   AddSimpleBlock(&cb, kVideoTrackNum, 15);
   scoped_ptr<Cluster> cluster_a(cb.Finish());
 
   EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size()));
 
   // Verify that AppendData() doesn't accept more data now.
-  cb.SetClusterTimecode(20);
-  AddSimpleBlock(&cb, kAudioTrackNum, 20);
-  AddSimpleBlock(&cb, kVideoTrackNum, 20);
-  scoped_ptr<Cluster> cluster_b(cb.Finish());
+  scoped_ptr<Cluster> cluster_b(GenerateCluster(20, 2));
   EXPECT_FALSE(demuxer_->AppendData(kSourceId, cluster_b->data(),
                                     cluster_b->size()));
 }
 
 TEST_F(ChunkDemuxerTest, TestBackwardsAndBeforeClusterTimecode) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
   ClusterBuilder cb;
 
   // Test timecodes going backwards and including values less than the cluster
   // timecode.
   cb.SetClusterTimecode(5);
   AddSimpleBlock(&cb, kAudioTrackNum, 5);
   AddSimpleBlock(&cb, kVideoTrackNum, 5);
   AddSimpleBlock(&cb, kAudioTrackNum, 3);
   AddSimpleBlock(&cb, kVideoTrackNum, 3);
   scoped_ptr<Cluster> cluster_a(cb.Finish());
 
   EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size()));
 
   // Verify that AppendData() doesn't accept more data now.
-  cb.SetClusterTimecode(6);
-  AddSimpleBlock(&cb, kAudioTrackNum, 6);
-  AddSimpleBlock(&cb, kVideoTrackNum, 6);
-  scoped_ptr<Cluster> cluster_b(cb.Finish());
+  scoped_ptr<Cluster> cluster_b(GenerateCluster(6, 2));
   EXPECT_FALSE(demuxer_->AppendData(kSourceId, cluster_b->data(),
                                     cluster_b->size()));
 }
 
 
 TEST_F(ChunkDemuxerTest, TestPerStreamMonotonicallyIncreasingTimestamps) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
   ClusterBuilder cb;
 
@@ skipping 26 matching lines @@
 
   cb.SetClusterTimecode(5);
   AddSimpleBlock(&cb, kAudioTrackNum, 5);
   AddSimpleBlock(&cb, kVideoTrackNum, 7);
   scoped_ptr<Cluster> cluster_b(cb.Finish());
 
   EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   ASSERT_TRUE(AppendData(cluster_b->data(), cluster_b->size()));
 
   // Verify that AppendData() doesn't accept more data now.
-  cb.SetClusterTimecode(10);
-  AddSimpleBlock(&cb, kAudioTrackNum, 10);
-  AddSimpleBlock(&cb, kVideoTrackNum, 10);
-  scoped_ptr<Cluster> cluster_c(cb.Finish());
+  scoped_ptr<Cluster> cluster_c(GenerateCluster(10, 2));
   EXPECT_FALSE(demuxer_->AppendData(kSourceId, cluster_c->data(),
                                     cluster_c->size()));
 }
 
 // Test the case where a cluster is passed to AppendData() before
 // INFO & TRACKS data.
 TEST_F(ChunkDemuxerTest, TestClusterBeforeInfoTracks) {
   EXPECT_CALL(*client_, DemuxerOpened(_));
   demuxer_->Initialize(
       &host_, NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN));
 
   ASSERT_EQ(AddId(), ChunkDemuxer::kOk);
 
-  ClusterBuilder cb;
-  cb.SetClusterTimecode(0);
-  AddSimpleBlock(&cb, kVideoTrackNum, 0);
-  scoped_ptr<Cluster> cluster(cb.Finish());
+  scoped_ptr<Cluster> cluster(GenerateCluster(0, 1));
 
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 }
 
 // Test cases where we get an EndOfStream() call during initialization.
 TEST_F(ChunkDemuxerTest, TestEOSDuringInit) {
   EXPECT_CALL(*client_, DemuxerOpened(_));
   demuxer_->Initialize(
       &host_, NewExpectedStatusCB(DEMUXER_ERROR_COULD_NOT_OPEN));
   demuxer_->EndOfStream(PIPELINE_OK);
 }
 
 TEST_F(ChunkDemuxerTest, TestDecodeErrorEndOfStream) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
-  ClusterBuilder cb;
-  cb.SetClusterTimecode(0);
-  AddSimpleBlock(&cb, kAudioTrackNum, 0);
-  AddSimpleBlock(&cb, kVideoTrackNum, 0);
-  AddSimpleBlock(&cb, kAudioTrackNum, 23);
-  AddSimpleBlock(&cb, kVideoTrackNum, 33);
-  scoped_ptr<Cluster> cluster(cb.Finish());
+  scoped_ptr<Cluster> cluster(GenerateCluster(0, 4));
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 
   EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
   demuxer_->EndOfStream(PIPELINE_ERROR_DECODE);
 }
 
 TEST_F(ChunkDemuxerTest, TestNetworkErrorEndOfStream) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
-  ClusterBuilder cb;
-  cb.SetClusterTimecode(0);
-  AddSimpleBlock(&cb, kAudioTrackNum, 0);
-  AddSimpleBlock(&cb, kVideoTrackNum, 0);
-  AddSimpleBlock(&cb, kAudioTrackNum, 23);
-  AddSimpleBlock(&cb, kVideoTrackNum, 33);
-  scoped_ptr<Cluster> cluster(cb.Finish());
+  scoped_ptr<Cluster> cluster(GenerateCluster(0, 4));
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 
   EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_NETWORK));
   demuxer_->EndOfStream(PIPELINE_ERROR_NETWORK);
 }
 
 // Helper class to reduce duplicate code when testing end of stream
 // Read() behavior.
 class EndOfStreamHelper {
  public:
@@ skipping 50 matching lines @@
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
 
   bool audio_read_done_1 = false;
   bool video_read_done_1 = false;
   EndOfStreamHelper end_of_stream_helper_1(demuxer_);
   EndOfStreamHelper end_of_stream_helper_2(demuxer_);
 
   audio->Read(base::Bind(&OnReadDone,
-                         base::TimeDelta::FromMilliseconds(32),
+                         base::TimeDelta::FromMilliseconds(0),
                          &audio_read_done_1));
 
   video->Read(base::Bind(&OnReadDone,
-                         base::TimeDelta::FromMilliseconds(123),
+                         base::TimeDelta::FromMilliseconds(1),
                          &video_read_done_1));
 
   end_of_stream_helper_1.RequestReads();
   end_of_stream_helper_2.RequestReads();
 
-  ClusterBuilder cb;
-  cb.SetClusterTimecode(0);
-  AddSimpleBlock(&cb, kAudioTrackNum, 32);
-  AddSimpleBlock(&cb, kVideoTrackNum, 123);
-  scoped_ptr<Cluster> cluster(cb.Finish());
+  scoped_ptr<Cluster> cluster(GenerateCluster(0, 2));
 
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 
   EXPECT_TRUE(audio_read_done_1);
   EXPECT_TRUE(video_read_done_1);
   end_of_stream_helper_1.CheckIfReadDonesWereCalled(false);
   end_of_stream_helper_2.CheckIfReadDonesWereCalled(false);
 
   demuxer_->EndOfStream(PIPELINE_OK);
 
@@ skipping 11 matching lines @@
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
 
   bool audio_read_done_1 = false;
   bool video_read_done_1 = false;
   EndOfStreamHelper end_of_stream_helper_1(demuxer_);
   EndOfStreamHelper end_of_stream_helper_2(demuxer_);
   EndOfStreamHelper end_of_stream_helper_3(demuxer_);
 
   audio->Read(base::Bind(&OnReadDone,
-                         base::TimeDelta::FromMilliseconds(32),
+                         base::TimeDelta::FromMilliseconds(0),
                          &audio_read_done_1));
 
   video->Read(base::Bind(&OnReadDone,
-                         base::TimeDelta::FromMilliseconds(123),
+                         base::TimeDelta::FromMilliseconds(1),
                          &video_read_done_1));
 
   end_of_stream_helper_1.RequestReads();
 
-  ClusterBuilder cb;
-  cb.SetClusterTimecode(0);
-  AddSimpleBlock(&cb, kAudioTrackNum, 32);
-  AddSimpleBlock(&cb, kVideoTrackNum, 123);
-  scoped_ptr<Cluster> cluster(cb.Finish());
+  scoped_ptr<Cluster> cluster(GenerateCluster(0, 2));
 
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 
   EXPECT_TRUE(audio_read_done_1);
   EXPECT_TRUE(video_read_done_1);
   end_of_stream_helper_1.CheckIfReadDonesWereCalled(false);
 
   demuxer_->EndOfStream(PIPELINE_OK);
 
   end_of_stream_helper_1.CheckIfReadDonesWereCalled(true);
@@ skipping 13 matching lines @@
   EXPECT_CALL(*client_, DemuxerOpened(_));
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
 
   ASSERT_EQ(AddId(), ChunkDemuxer::kOk);
 
   scoped_array<uint8> info_tracks;
   int info_tracks_size = 0;
   CreateInfoTracks(true, true, false, &info_tracks, &info_tracks_size);
 
-  ClusterBuilder cb;
-  cb.SetClusterTimecode(0);
-  AddSimpleBlock(&cb, kAudioTrackNum, 32, 512);
-  AddSimpleBlock(&cb, kVideoTrackNum, 123, 1024);
-  scoped_ptr<Cluster> cluster_a(cb.Finish());
-
-  cb.SetClusterTimecode(125);
-  AddSimpleBlock(&cb, kAudioTrackNum, 125, 2048);
-  AddSimpleBlock(&cb, kVideoTrackNum, 150, 2048);
-  scoped_ptr<Cluster> cluster_b(cb.Finish());
+  scoped_ptr<Cluster> cluster_a(GenerateCluster(0, 4));
+  scoped_ptr<Cluster> cluster_b(GenerateCluster(68, 4));
 
   size_t buffer_size = info_tracks_size + cluster_a->size() + cluster_b->size();
   scoped_array<uint8> buffer(new uint8[buffer_size]);
   uint8* dst = buffer.get();
   memcpy(dst, info_tracks.get(), info_tracks_size);
   dst += info_tracks_size;
 
   memcpy(dst, cluster_a->data(), cluster_a->size());
   dst += cluster_a->size();
 
   memcpy(dst, cluster_b->data(), cluster_b->size());
   dst += cluster_b->size();
 
   ASSERT_TRUE(AppendDataInPieces(buffer.get(), buffer_size));
 
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
 
   ASSERT_TRUE(audio);
   ASSERT_TRUE(video);
 
-  bool audio_read_done = false;
-  bool video_read_done = false;
-  audio->Read(base::Bind(&OnReadDone,
-                         base::TimeDelta::FromMilliseconds(32),
-                         &audio_read_done));
-
-  video->Read(base::Bind(&OnReadDone,
-                         base::TimeDelta::FromMilliseconds(123),
-                         &video_read_done));
-
-  EXPECT_TRUE(audio_read_done);
-  EXPECT_TRUE(video_read_done);
-
-  audio_read_done = false;
-  video_read_done = false;
-  audio->Read(base::Bind(&OnReadDone,
-                         base::TimeDelta::FromMilliseconds(125),
-                         &audio_read_done));
-
-  video->Read(base::Bind(&OnReadDone,
-                         base::TimeDelta::FromMilliseconds(150),
-                         &video_read_done));
-
-  EXPECT_TRUE(audio_read_done);
-  EXPECT_TRUE(video_read_done);
+  GenerateExpectedReads(0, 4, audio, video);
+  GenerateExpectedReads(68, 4, audio, video);
 }
 
 TEST_F(ChunkDemuxerTest, TestWebMFile_AudioAndVideo) {
   struct BufferTimestamps buffer_timestamps[] = {
     {0, 0},
     {33, 3},
     {67, 6},
     {100, 9},
     {133, 12},
     {kSkip, kSkip},
@@ skipping 42 matching lines @@
   };
 
   ASSERT_TRUE(ParseWebMFile("bear-320x240-video-only.webm", buffer_timestamps,
                             base::TimeDelta::FromMilliseconds(2703)));
 }
 
 // Verify that we output buffers before the entire cluster has been parsed.
 TEST_F(ChunkDemuxerTest, TestIncrementalClusterParsing) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
-  ClusterBuilder cb;
-  cb.SetClusterTimecode(0);
-  AddSimpleBlock(&cb, kAudioTrackNum, 0, 10);
-  AddSimpleBlock(&cb, kVideoTrackNum, 1, 10);
-  AddSimpleBlock(&cb, kVideoTrackNum, 2, 10);
-  AddSimpleBlock(&cb, kAudioTrackNum, 3, 10);
-  scoped_ptr<Cluster> cluster(cb.Finish());
-
+  scoped_ptr<Cluster> cluster(GenerateCluster(0, 6));
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
 
   bool audio_read_done = false;
   bool video_read_done = false;
   audio->Read(base::Bind(&OnReadDone,
                          base::TimeDelta::FromMilliseconds(0),
                          &audio_read_done));
@@ skipping 21 matching lines @@
   for (; i < cluster->size() && !video_read_done; ++i) {
     ASSERT_TRUE(AppendData(cluster->data() + i, 1));
   }
 
   EXPECT_TRUE(video_read_done);
   EXPECT_LT(i, cluster->size());
 
   audio_read_done = false;
   video_read_done = false;
   audio->Read(base::Bind(&OnReadDone,
-                         base::TimeDelta::FromMilliseconds(3),
+                         base::TimeDelta::FromMilliseconds(23),
                          &audio_read_done));
 
   video->Read(base::Bind(&OnReadDone,
-                         base::TimeDelta::FromMilliseconds(2),
+                         base::TimeDelta::FromMilliseconds(34),
                          &video_read_done));
 
   // Make sure the reads haven't completed yet.
   EXPECT_FALSE(audio_read_done);
   EXPECT_FALSE(video_read_done);
 
   // Append the remaining data.
+  ASSERT_LT(i, cluster->size());
   ASSERT_TRUE(AppendData(cluster->data() + i, cluster->size() - i));
 
   EXPECT_TRUE(audio_read_done);
   EXPECT_TRUE(video_read_done);
 }
 
 
 TEST_F(ChunkDemuxerTest, TestParseErrorDuringInit) {
   EXPECT_CALL(host_, OnDemuxerError(PIPELINE_ERROR_DECODE));
 
@@ skipping 31 matching lines @@
 
   std::vector<std::string> codecs(1);
   codecs[0] = "vp8";
   ASSERT_EQ(demuxer_->AddId(kSourceId, "video/webm", codecs),
             ChunkDemuxer::kOk);
 
   ASSERT_TRUE(AppendInfoTracks(true, true, false));
 }
 
 }  // namespace media