Cap sourceBuffered() on duration and truncate duration on EoS

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 29 matching lines @@
                                               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";
 static const char* kDefaultFirstClusterRange = "{ [0,46) }";
+static const int kDefaultFirstClusterDuration = 66;
+static const int kDefaultSecondClusterDuration = 132;

[acolwell GONE FROM CHROMIUM, 2012/08/01 17:09:45]

nit: Duration is misleading here. The cluster isn't 132ms long. It's 66ms.
Perhaps s/Duration/EndTimestamp/ ?

[vrk (LEFT CHROMIUM), 2012/08/02 18:23:00]

Done.

 
 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));
@@ skipping 1033 matching lines @@
                          &video_read_done_1));
 
   end_of_stream_helper_1.RequestReads();
   end_of_stream_helper_2.RequestReads();
 
   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);
 
+  EXPECT_CALL(host_, SetDuration(
+      base::TimeDelta::FromMilliseconds(kVideoBlockDuration)));
   demuxer_->EndOfStream(PIPELINE_OK);
 
   end_of_stream_helper_1.CheckIfReadDonesWereCalled(true);
   end_of_stream_helper_2.CheckIfReadDonesWereCalled(true);
 }
 
 // Make sure that all Read() calls after we get an EndOfStream()
 // call return an "end of stream" buffer.
 TEST_F(ChunkDemuxerTest, TestReadsAfterEndOfStream) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
@@ skipping 19 matching lines @@
   video->Read(base::Bind(&OnReadDone,
                          base::TimeDelta::FromMilliseconds(0),
                          &video_read_done_1));
 
   end_of_stream_helper_1.RequestReads();
 
   EXPECT_TRUE(audio_read_done_1);
   EXPECT_TRUE(video_read_done_1);
   end_of_stream_helper_1.CheckIfReadDonesWereCalled(false);
 
+  EXPECT_CALL(host_, SetDuration(
+      base::TimeDelta::FromMilliseconds(kVideoBlockDuration)));
   EXPECT_TRUE(demuxer_->EndOfStream(PIPELINE_OK));
 
   end_of_stream_helper_1.CheckIfReadDonesWereCalled(true);
 
   // Request a few more reads and make sure we immediately get
   // end of stream buffers.
   end_of_stream_helper_2.RequestReads();
   end_of_stream_helper_2.CheckIfReadDonesWereCalled(true);
 
   end_of_stream_helper_3.RequestReads();
@@ skipping 538 matching lines @@
   scoped_ptr<Cluster> cluster_a(
       GenerateSingleStreamCluster(0, 90, kAudioTrackNum, 90));
   scoped_ptr<Cluster> cluster_v(
       GenerateSingleStreamCluster(0, 100, kVideoTrackNum, 100));
 
   ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size()));
   ASSERT_TRUE(AppendData(cluster_v->data(), cluster_v->size()));
 
   CheckExpectedRanges("{ [0,90) }");
 
+  EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(100)));
   demuxer_->EndOfStream(PIPELINE_OK);
 
   CheckExpectedRanges("{ [0,100) }");
 }
 
 TEST_F(ChunkDemuxerTest, TestDifferentStreamTimecodes) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
@@ skipping 96 matching lines @@
 
   ASSERT_TRUE(AppendData(audio_id, cluster_a1->data(), cluster_a1->size()));
   ASSERT_TRUE(AppendData(video_id, cluster_v1->data(), cluster_v1->size()));
   ASSERT_TRUE(AppendData(video_id, cluster_v3->data(), cluster_v3->size()));
 
   CheckExpectedRanges(audio_id, "{ [0,35) }");
   CheckExpectedRanges(video_id, "{ [0,10) [30,50) }");
 
   // Make sure that end of stream fails because there is a gap between
   // the current position(0) and the end of the appended data.
+  EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(50)));
   ASSERT_FALSE(demuxer_->EndOfStream(PIPELINE_OK));
 
   // Seek to an time that is inside the last ranges for both streams
   // and verify that the EndOfStream() is successful.
   demuxer_->StartWaitingForSeek();
   demuxer_->Seek(base::TimeDelta::FromMilliseconds(30),
                  NewExpectedStatusCB(PIPELINE_OK));
 
   ASSERT_TRUE(demuxer_->EndOfStream(PIPELINE_OK));
 
@@ skipping 30 matching lines @@
 
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
   scoped_ptr<Cluster> cluster_a(kDefaultFirstCluster());
   scoped_ptr<Cluster> cluster_b(kDefaultSecondCluster());
   ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size()));
 
   demuxer_->StartWaitingForSeek();
 
   ASSERT_TRUE(AppendData(cluster_b->data(), cluster_b->size()));
+  EXPECT_CALL(host_, SetDuration(
+      base::TimeDelta::FromMilliseconds(kDefaultSecondClusterDuration)));
   demuxer_->EndOfStream(PIPELINE_OK);
 
   demuxer_->Seek(base::TimeDelta::FromSeconds(0),
                  NewExpectedStatusCB(PIPELINE_OK));
 
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
 
@@ skipping 250 matching lines @@
   scoped_ptr<Cluster> cluster = GenerateCluster(0, 2);
   // Append only part of the cluster data.
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size() - 13));
 
   // Setting a timestamp should fail because we're in the middle of a cluster.
   ASSERT_FALSE(demuxer_->SetTimestampOffset(kSourceId, 25));
 }
 
 TEST_F(ChunkDemuxerTest, TestDurationChange) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
+  static const int kStreamDuration = kDefaultDuration().InMilliseconds();
 
   // Add data leading up to the currently set duration.
   scoped_ptr<Cluster> first_cluster = GenerateCluster(
-      kDefaultDuration().InMilliseconds() - kAudioBlockDuration,
-      kDefaultDuration().InMilliseconds() - kVideoBlockDuration, 2);
+      kStreamDuration - kAudioBlockDuration,
+      kStreamDuration - kVideoBlockDuration, 2);
   ASSERT_TRUE(AppendData(first_cluster->data(), first_cluster->size()));
 
+  std::stringstream first_range;
+  first_range << "{ [" << kStreamDuration - kVideoBlockDuration << "," <<
+     kStreamDuration << ") }";
+  CheckExpectedRanges(kSourceId, first_range.str());

[acolwell GONE FROM CHROMIUM, 2012/08/01 17:09:45]

Just explicitly put the strings here and below. I'm pretty sure if these values
change other tests will break as well. You can add a comment above the call if
you want to clarify where the numbers came from. I think that would be clearer
than this.

[vrk (LEFT CHROMIUM), 2012/08/02 18:23:00]

Done, and I agree I think it's clearer this way.

+
+  // Add data at the currently set duration. The duration should not increase.
+  scoped_ptr<Cluster> second_cluster = GenerateCluster(
+      kDefaultDuration().InMilliseconds(), 2);
+  ASSERT_TRUE(AppendData(second_cluster->data(), second_cluster->size()));
+
+  // Range should not be affected.
+  CheckExpectedRanges(kSourceId, first_range.str());
+
   // Now add data past the duration and expect a new duration to be signalled.
-  scoped_ptr<Cluster> second_cluster = GenerateCluster(
-      kDefaultDuration().InMilliseconds(), 4);
+  static const int kNewStreamDuration =
+      kStreamDuration + kAudioBlockDuration * 2;
+  scoped_ptr<Cluster> third_cluster = GenerateCluster(
+      kStreamDuration + kAudioBlockDuration,
+      kStreamDuration + kVideoBlockDuration, 2);
   EXPECT_CALL(host_, SetDuration(
-      kDefaultDuration() + base::TimeDelta::FromMilliseconds(
-          kAudioBlockDuration * 2)));
-  ASSERT_TRUE(AppendData(second_cluster->data(), second_cluster->size()));
+      base::TimeDelta::FromMilliseconds(kNewStreamDuration)));
+  ASSERT_TRUE(AppendData(third_cluster->data(), third_cluster->size()));
+
+  // See that the range has increased appropriately.
+  std::stringstream second_range;
+  second_range << "{ [" << kStreamDuration - kVideoBlockDuration << "," <<
+     kNewStreamDuration << ") }";
+  CheckExpectedRanges(kSourceId, second_range.str());
 }
 
 TEST_F(ChunkDemuxerTest, TestDurationChangeTimestampOffset) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
   ASSERT_TRUE(demuxer_->SetTimestampOffset(kSourceId,
                                            kDefaultDuration().InSecondsF()));
   scoped_ptr<Cluster> cluster = GenerateCluster(0, 4);
 
   EXPECT_CALL(host_, SetDuration(
       kDefaultDuration() + base::TimeDelta::FromMilliseconds(
           kAudioBlockDuration * 2)));
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 }
 
+TEST_F(ChunkDemuxerTest, TestEndOfStreamTruncateDuration) {
+  ASSERT_TRUE(InitDemuxer(true, true, false));
+
+  scoped_ptr<Cluster> cluster_a(kDefaultFirstCluster());
+  ASSERT_TRUE(AppendData(cluster_a->data(), cluster_a->size()));
+
+  EXPECT_CALL(host_, SetDuration(
+      base::TimeDelta::FromMilliseconds(kDefaultFirstClusterDuration)));
+  demuxer_->EndOfStream(PIPELINE_OK);
+}
+
 }  // namespace media