Fix ChunkDemuxer so it properly outputs buffered ranges.

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 d55dff4fc2d00fff1676bf6badba0e24d0afe798..4078dea4d41f66f2ba7b6bab0a69e6af43aabd9c 100644
--- a/media/filters/chunk_demuxer_unittest.cc
+++ b/media/filters/chunk_demuxer_unittest.cc
@@ -256,7 +256,7 @@ class ChunkDemuxerTest : public testing::Test {
         return false;
       start += append_size;
 
-      EXPECT_GT(buffered_bytes_, old_buffered_bytes);
+      EXPECT_GE(buffered_bytes_, old_buffered_bytes);
     }
     return true;
   }
@@ -284,8 +284,11 @@ class ChunkDemuxerTest : public testing::Test {
 
   PipelineStatusCB CreateInitDoneCB(const base::TimeDelta& expected_duration,
                                     PipelineStatus expected_status) {
-    if (expected_status == PIPELINE_OK)
+    if (expected_status == PIPELINE_OK) {
+      if (expected_duration != kInfiniteDuration())
+        EXPECT_CALL(host_, SetTotalBytes(_));
       EXPECT_CALL(host_, SetDuration(expected_duration));
+    }
 
     return base::Bind(&ChunkDemuxerTest::InitDoneCalled,
                       base::Unretained(this),
@@ -463,26 +466,17 @@ class ChunkDemuxerTest : public testing::Test {
     }
   }
 
-  std::pair<base::TimeDelta, base::TimeDelta> CreateRange(
-      int start_time, int block_count, int block_duration) {
-    return std::make_pair(base::TimeDelta::FromMilliseconds(start_time),
-                          base::TimeDelta::FromMilliseconds(start_time +
-                              (block_count * block_duration)));
-  }
+  void CheckExpectedRanges(const std::string& expected) {
+    Ranges<base::TimeDelta> r = demuxer_->GetBufferedRanges(kSourceId);
 
-  void CheckExpectedRanges(const ChunkDemuxer::Ranges& expected_times) {
-    ChunkDemuxer::Ranges actual_times;
-    demuxer_->GetBufferedRanges(kSourceId, &actual_times);
-    EXPECT_EQ(expected_times.size(), actual_times.size());
-
-    for (ChunkDemuxer::Ranges::const_iterator actual_itr =
-         actual_times.begin(), expected_itr = expected_times.begin();
-         actual_itr != actual_times.end() &&
-         expected_itr != expected_times.end();
-         actual_itr++, expected_itr++) {
-      EXPECT_EQ(expected_itr->first, actual_itr->first);
-      EXPECT_EQ(expected_itr->second, actual_itr->second);
+    std::stringstream ss;
+    ss << "{ ";
+    for (size_t i = 0; i < r.size(); ++i) {
+      ss << "[" << r.start(i).InMilliseconds() << ","
+         << r.end(i).InMilliseconds() << ") ";
     }
+    ss << "}";
+    EXPECT_EQ(expected, ss.str());

[Ami GONE FROM CHROMIUM, 2012/06/19 17:40:37]

reverse args?

[acolwell GONE FROM CHROMIUM, 2012/06/19 19:50:15]

This order makes |expected| appear with the error message's "Expected:" text. 

[Ami GONE FROM CHROMIUM, 2012/06/19 20:23:38]

True, but it runs counter to the order used in most media code, as well as
hundreds of years of mathematical notation...  Whatever.

[acolwell GONE FROM CHROMIUM, 2012/06/19 22:39:36]

Switched here and in source_buffer_stream_unittest.

   }
 
   MOCK_METHOD1(ReadDone, void(const scoped_refptr<DecoderBuffer>&));
@@ -1427,21 +1421,17 @@ TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioIdOnly) {
   // Test a simple cluster.
   scoped_ptr<Cluster> cluster_1(GenerateSingleStreamCluster(0, 4,
                                 kAudioTrackNum, kAudioBlockDuration));
-  ChunkDemuxer::Ranges expected;
-  expected.push_back(CreateRange(0, 4, kAudioBlockDuration));
-
   ASSERT_TRUE(AppendData(cluster_1->data(), cluster_1->size()));
 
-  CheckExpectedRanges(expected);
+  CheckExpectedRanges("{ [0,92) }");

[Ami GONE FROM CHROMIUM, 2012/06/19 17:40:37]

Is it easy to see that these numbers are right, here and below? (until the
ranges become more explicitly in terms of time)

[acolwell GONE FROM CHROMIUM, 2012/06/19 19:50:15]

I've changed GenerateSingleStreamCluster() so that it uses timestamps instead of
a block count. This makes it clearer where the values in the ranges are coming
from.

 
   // Append a disjoint cluster to check for two separate ranges.
   scoped_ptr<Cluster> cluster_2(GenerateSingleStreamCluster(150, 3,
                                 kAudioTrackNum, kAudioBlockDuration));
-  expected.push_back(CreateRange(150, 3, kAudioBlockDuration));
 
   ASSERT_TRUE(AppendData(cluster_2->data(), cluster_2->size()));
 
-  CheckExpectedRanges(expected);
+  CheckExpectedRanges("{ [0,92) [150,219) }");
 }
 
 // Test ranges in a video-only stream.
@@ -1456,21 +1446,18 @@ TEST_F(ChunkDemuxerTest, GetBufferedRanges_VideoIdOnly) {
   // Test a simple cluster.
   scoped_ptr<Cluster> cluster_1(GenerateSingleStreamCluster(0, 4,
                                 kVideoTrackNum, kVideoBlockDuration));
-  ChunkDemuxer::Ranges expected;
-  expected.push_back(CreateRange(0, 4, kVideoBlockDuration));
 
   ASSERT_TRUE(AppendData(cluster_1->data(), cluster_1->size()));
 
-  CheckExpectedRanges(expected);
+  CheckExpectedRanges("{ [0,132) }");
 
   // Append a disjoint cluster to check for two separate ranges.
   scoped_ptr<Cluster> cluster_2(GenerateSingleStreamCluster(150, 3,
                                 kVideoTrackNum, kVideoBlockDuration));
-  expected.push_back(CreateRange(150, 3, kVideoBlockDuration));
 
   ASSERT_TRUE(AppendData(cluster_2->data(), cluster_2->size()));
 
-  CheckExpectedRanges(expected);
+  CheckExpectedRanges("{ [0,132) [150,249) }");
 }
 
 TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioVideo) {
@@ -1487,13 +1474,10 @@ TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioVideo) {
   scoped_ptr<Cluster> cluster_v0(
       GenerateSingleStreamCluster(0, 1, kVideoTrackNum, kVideoBlockDuration));
 
-  ChunkDemuxer::Ranges expected;
-  expected.push_back(CreateRange(0, 1, kAudioBlockDuration));
-
   ASSERT_TRUE(AppendData(cluster_a0->data(), cluster_a0->size()));
   ASSERT_TRUE(AppendData(cluster_v0->data(), cluster_v0->size()));
 
-  CheckExpectedRanges(expected);
+  CheckExpectedRanges("{ [0,23) }");
 
   // Audio: 100 -> 150
   // Video: 120 -> 170
@@ -1504,12 +1488,10 @@ TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioVideo) {
   scoped_ptr<Cluster> cluster_v1(
       GenerateSingleStreamCluster(120, 1, kVideoTrackNum, 50));
 
-  expected.push_back(CreateRange(120, 1, 30));
-
   ASSERT_TRUE(AppendData(cluster_a1->data(), cluster_a1->size()));
   ASSERT_TRUE(AppendData(cluster_v1->data(), cluster_v1->size()));
 
-  CheckExpectedRanges(expected);
+  CheckExpectedRanges("{ [0,23) [120,150) }");
 
   // Audio: 220 -> 290
   // Video: 200 -> 270
@@ -1520,12 +1502,10 @@ TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioVideo) {
   scoped_ptr<Cluster> cluster_v2(
       GenerateSingleStreamCluster(200, 1, kVideoTrackNum, 70));
 
-  expected.push_back(CreateRange(220, 1, 50));
-
   ASSERT_TRUE(AppendData(cluster_a2->data(), cluster_a2->size()));
   ASSERT_TRUE(AppendData(cluster_v2->data(), cluster_v2->size()));
 
-  CheckExpectedRanges(expected);
+  CheckExpectedRanges("{ [0,23) [120,150) [220,270) }");
 
   // Audio: 320 -> 350
   // Video: 300 -> 370
@@ -1536,12 +1516,10 @@ TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioVideo) {
   scoped_ptr<Cluster> cluster_v3(
       GenerateSingleStreamCluster(300, 1, kVideoTrackNum, 70));
 
-  expected.push_back(CreateRange(320, 1, 30));
-
   ASSERT_TRUE(AppendData(cluster_a3->data(), cluster_a3->size()));
   ASSERT_TRUE(AppendData(cluster_v3->data(), cluster_v3->size()));
 
-  CheckExpectedRanges(expected);
+  CheckExpectedRanges("{ [0,23) [120,150) [220,270) [320,350) }");
 
   // Audio: 400 -> 470
   // Video: 420 -> 450
@@ -1552,25 +1530,23 @@ TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioVideo) {
   scoped_ptr<Cluster> cluster_v4(
       GenerateSingleStreamCluster(420, 1, kVideoTrackNum, 30));
 
-  expected.push_back(CreateRange(420, 1, 30));
-
   ASSERT_TRUE(AppendData(cluster_a4->data(), cluster_a4->size()));
   ASSERT_TRUE(AppendData(cluster_v4->data(), cluster_v4->size()));
 
-  CheckExpectedRanges(expected);
+  CheckExpectedRanges("{ [0,23) [120,150) [220,270) [320,350) [420,450) }");
 
   // Appending within buffered range should not affect buffered ranges.
   scoped_ptr<Cluster> cluster_a5(
       GenerateSingleStreamCluster(430, 1, kAudioTrackNum, 20));
   ASSERT_TRUE(AppendData(cluster_a5->data(), cluster_a5->size()));
-  CheckExpectedRanges(expected);
+  CheckExpectedRanges("{ [0,23) [120,150) [220,270) [320,350) [420,450) }");
 
   // Appending to single stream outside buffered ranges should not affect
   // buffered ranges.
   scoped_ptr<Cluster> cluster_v5(
       GenerateSingleStreamCluster(530, 1, kVideoTrackNum, 10));
   ASSERT_TRUE(AppendData(cluster_v5->data(), cluster_v5->size()));
-  CheckExpectedRanges(expected);
+  CheckExpectedRanges("{ [0,23) [120,150) [220,270) [320,350) [420,450) }");
 }
 
 // Once EndOfStream() is called, GetBufferedRanges should not cut off any
@@ -1583,14 +1559,15 @@ TEST_F(ChunkDemuxerTest, GetBufferedRanges_EndOfStream) {
       GenerateSingleStreamCluster(0, 1, kAudioTrackNum, 90));
   scoped_ptr<Cluster> cluster_v(
       GenerateSingleStreamCluster(0, 1, kVideoTrackNum, 100));
-  ChunkDemuxer::Ranges expected;
-  expected.push_back(CreateRange(0, 1, 100));
 
   ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size()));
   ASSERT_TRUE(AppendData(cluster_v->data(), cluster_v->size()));
 
+  CheckExpectedRanges("{ [0,90) }");
+
   demuxer_->EndOfStream(PIPELINE_OK);
-  CheckExpectedRanges(expected);
+
+  CheckExpectedRanges("{ [0,100) }");
 }
 
 TEST_F(ChunkDemuxerTest, TestDifferentStreamTimecodes) {