Fix ChunkDemuxer so it properly outputs buffered ranges.

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/decoder_buffer.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_demuxer_host.h"
 #include "media/base/test_data_util.h"
@@ skipping 238 matching lines @@
     const uint8* start = data;
     const uint8* end = data + length;
     while (start < end) {
       int64 old_buffered_bytes = buffered_bytes_;
       size_t append_size = std::min(piece_size,
                                     static_cast<size_t>(end - start));
       if (!AppendData(start, append_size))
         return false;
       start += append_size;
 
-      EXPECT_GT(buffered_bytes_, old_buffered_bytes);
+      EXPECT_GE(buffered_bytes_, old_buffered_bytes);
     }
     return true;
   }
 
   bool AppendInitSegment(bool has_audio, bool has_video,
                          bool video_content_encoded) {
     return AppendInitSegment(kSourceId, has_audio, has_video,
                              video_content_encoded);
   }
 
   bool AppendInitSegment(const std::string& source_id,
                          bool has_audio, bool has_video,
                          bool video_content_encoded) {
     scoped_array<uint8> info_tracks;
     int info_tracks_size = 0;
     CreateInitSegment(has_audio, has_video, video_content_encoded,
                       &info_tracks, &info_tracks_size);
     return AppendData(source_id, info_tracks.get(), info_tracks_size);
   }
 
   void InitDoneCalled(PipelineStatus expected_status,
                       PipelineStatus status) {
     EXPECT_EQ(status, expected_status);
   }
 
   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),
                       expected_status);
   }
 
   bool InitDemuxer(bool has_audio, bool has_video,
                    bool video_content_encoded) {
     PipelineStatus expected_status =
         (has_audio || has_video) ? PIPELINE_OK : DEMUXER_ERROR_COULD_NOT_OPEN;
@@ skipping 157 matching lines @@
                              DemuxerStream* stream, int block_duration) {
     CHECK_GT(block_count, 0);
     int stream_timecode = timecode;
 
     for (int i = 0; i < block_count; i++) {
       ExpectRead(stream, stream_timecode);
       stream_timecode += block_duration;
     }
   }
 
-  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>&));
 
   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 924 matching lines @@
   EXPECT_CALL(*client_, DemuxerOpened(_));
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
 
   ASSERT_EQ(AddId(kSourceId, true, false), ChunkDemuxer::kOk);
   ASSERT_TRUE(AppendInitSegment(true, false, false));
 
   // 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.
 TEST_F(ChunkDemuxerTest, GetBufferedRanges_VideoIdOnly) {
   EXPECT_CALL(*client_, DemuxerOpened(_));
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK));
 
   ASSERT_EQ(AddId(kSourceId, false, true), ChunkDemuxer::kOk);
   ASSERT_TRUE(AppendInitSegment(false, true, false));
 
   // 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) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
   // Audio: 0 -> 23
   // Video: 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.
   scoped_ptr<Cluster> cluster_a0(
       GenerateSingleStreamCluster(0, 1, kAudioTrackNum, kAudioBlockDuration));
 
   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
   // Buffered Range: 120 -> 150  (end overlap)
   scoped_ptr<Cluster> cluster_a1(
       GenerateSingleStreamCluster(100, 1, kAudioTrackNum, 50));
 
   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
   // Buffered Range: 220 -> 270  (front overlap)
   scoped_ptr<Cluster> cluster_a2(
       GenerateSingleStreamCluster(220, 1, kAudioTrackNum, 70));
 
   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
   // Buffered Range: 320 -> 350  (complete overlap, audio)
   scoped_ptr<Cluster> cluster_a3(
       GenerateSingleStreamCluster(320, 1, kAudioTrackNum, 30));
 
   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
   // Buffered Range: 420 -> 450  (complete overlap, video)
   scoped_ptr<Cluster> cluster_a4(
       GenerateSingleStreamCluster(400, 1, kAudioTrackNum, 70));
 
   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
 // over-hanging tails at the end of the ranges as this is likely due to block
 // duration differences.
 TEST_F(ChunkDemuxerTest, GetBufferedRanges_EndOfStream) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
   scoped_ptr<Cluster> cluster_a(
       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) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
 
@@ skipping 22 matching lines @@
 TEST_F(ChunkDemuxerTest, TestCodecPrefixMatching) {
   std::vector<std::string> codecs;
   codecs.push_back("avc1.4D4041");
   codecs.push_back("mp4a.40.2");
 
   EXPECT_EQ(ChunkDemuxer::kOk,
             demuxer_->AddId("source_id", "video/mp4", codecs));
 }
 
 }  // namespace media