Enable round-tripping and updating of WebSourceBufferImpl timestamp offset

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 473 matching lines @@
     if (expected_status == PIPELINE_OK)
       expected_duration = kDefaultDuration();
 
     EXPECT_CALL(*this, DemuxerOpened());
     demuxer_->Initialize(
         &host_, CreateInitDoneCB(expected_duration, expected_status), true);
 
     if (AddId(kSourceId, stream_flags) != ChunkDemuxer::kOk)
       return false;
 
+    EXPECT_EQ(0.0, demuxer_->GetTimestampOffset(kSourceId));
+
     AppendInitSegmentWithEncryptedInfo(
         kSourceId, stream_flags,
         is_audio_encrypted, is_video_encrypted);
     return true;
   }
 
   bool InitDemuxerAudioAndVideoSourcesText(const std::string& audio_id,
                                            const std::string& video_id,
                                            bool has_text) {
     EXPECT_CALL(*this, DemuxerOpened());
@@ skipping 2068 matching lines @@
   // seek to a new location that has the same configuration as
   // the start of the file without a Read() in the middle.
   Seek(base::TimeDelta::FromMilliseconds(527));
   Seek(base::TimeDelta::FromMilliseconds(801));
 
   // Verify that no config change is signalled.
   ExpectRead(DemuxerStream::VIDEO, 801);
   ASSERT_TRUE(video_config_1.Matches(video->video_decoder_config()));
 }
 
+TEST_F(ChunkDemuxerTest, TimestampOffsetUserRoundTrips) {
+  ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
+
+  // Set an offset value that has greater precision than base::TimeDelta
+  // microsecond granularity, and confirm that the exact value is returned
+  // when getting the offset.
+  double super_precise_offset = 99.123456789;
+  ASSERT_TRUE(demuxer_->SetTimestampOffset(kSourceId, super_precise_offset));
+  EXPECT_EQ(super_precise_offset, demuxer_->GetTimestampOffset(kSourceId));
+}
+
 TEST_F(ChunkDemuxerTest, TimestampPositiveOffset) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
-  ASSERT_TRUE(demuxer_->SetTimestampOffset(
-      kSourceId, base::TimeDelta::FromSeconds(30)));
+  ASSERT_TRUE(demuxer_->SetTimestampOffset(kSourceId, 30));
   AppendCluster(GenerateCluster(0, 2));
 
   Seek(base::TimeDelta::FromMilliseconds(30000));
 
   GenerateExpectedReads(30000, 2);
 }
 
 TEST_F(ChunkDemuxerTest, TimestampNegativeOffset) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
-  ASSERT_TRUE(demuxer_->SetTimestampOffset(
-      kSourceId, base::TimeDelta::FromSeconds(-1)));
+  ASSERT_TRUE(demuxer_->SetTimestampOffset(kSourceId, -1));
   AppendCluster(GenerateCluster(1000, 2));
 
   GenerateExpectedReads(0, 2);
 }
 
 TEST_F(ChunkDemuxerTest, TimestampOffsetSeparateStreams) {
   std::string audio_id = "audio1";
   std::string video_id = "video1";
   ASSERT_TRUE(InitDemuxerAudioAndVideoSources(audio_id, video_id));
 
-  ASSERT_TRUE(demuxer_->SetTimestampOffset(
-      audio_id, base::TimeDelta::FromMilliseconds(-2500)));
-  ASSERT_TRUE(demuxer_->SetTimestampOffset(
-      video_id, base::TimeDelta::FromMilliseconds(-2500)));
+  ASSERT_TRUE(demuxer_->SetTimestampOffset(audio_id, -2.5));
+  ASSERT_TRUE(demuxer_->SetTimestampOffset(video_id, -2.5));
   AppendCluster(audio_id, GenerateSingleStreamCluster(2500,
       2500 + kAudioBlockDuration * 4, kAudioTrackNum, kAudioBlockDuration));
   AppendCluster(video_id, GenerateSingleStreamCluster(2500,
       2500 + kVideoBlockDuration * 4, kVideoTrackNum, kVideoBlockDuration));
   GenerateAudioStreamExpectedReads(0, 4);
   GenerateVideoStreamExpectedReads(0, 4);
 
   Seek(base::TimeDelta::FromMilliseconds(27300));
 
-  ASSERT_TRUE(demuxer_->SetTimestampOffset(
-      audio_id, base::TimeDelta::FromMilliseconds(27300)));
-  ASSERT_TRUE(demuxer_->SetTimestampOffset(
-      video_id, base::TimeDelta::FromMilliseconds(27300)));
+  ASSERT_TRUE(demuxer_->SetTimestampOffset(audio_id, 27.3));
+  ASSERT_TRUE(demuxer_->SetTimestampOffset(video_id, 27.3));
   AppendCluster(audio_id, GenerateSingleStreamCluster(
       0, kAudioBlockDuration * 4, kAudioTrackNum, kAudioBlockDuration));
   AppendCluster(video_id, GenerateSingleStreamCluster(
       0, kVideoBlockDuration * 4, kVideoTrackNum, kVideoBlockDuration));
   GenerateVideoStreamExpectedReads(27300, 4);
   GenerateAudioStreamExpectedReads(27300, 4);
 }
 
 TEST_F(ChunkDemuxerTest, TimestampOffsetMidMediaSegment) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   scoped_ptr<Cluster> cluster = GenerateCluster(0, 2);
   // Append only part of the cluster data.
   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, base::TimeDelta::FromSeconds(25)));
+  ASSERT_FALSE(demuxer_->SetTimestampOffset(kSourceId, 25));
 
   demuxer_->Abort(kSourceId);
   // After Abort(), setting a timestamp should succeed since we're no longer
   // in the middle of a cluster
-  ASSERT_TRUE(demuxer_->SetTimestampOffset(
-      kSourceId, base::TimeDelta::FromSeconds(25)));
+  ASSERT_TRUE(demuxer_->SetTimestampOffset(kSourceId, 25));
 }
 
 TEST_F(ChunkDemuxerTest, WebMParsingMediaSegmentDetection) {
   // 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)
   };
 
@@ skipping 10 matching lines @@
       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;
     AppendData(kBuffer + i, 1);
     bool expected_return_value = kExpectedReturnValues[i];
     EXPECT_EQ(expected_return_value, demuxer_->SetTimestampOffset(
-        kSourceId, base::TimeDelta::FromSeconds(25)));
+        kSourceId, 25));
     EXPECT_EQ(expected_return_value, demuxer_->SetSequenceMode(
         kSourceId, true));
     EXPECT_EQ(expected_return_value, demuxer_->SetSequenceMode(
         kSourceId, false));
   }
 }
 
 TEST_F(ChunkDemuxerTest, SetSequenceModeMidMediaSegment) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
@@ skipping 37 matching lines @@
                                 kStreamDuration + kVideoBlockDuration,
                                 2));
 
   // See that the range has increased appropriately.
   CheckExpectedRanges(kSourceId, "{ [201191,201270) }");
 }
 
 TEST_F(ChunkDemuxerTest, DurationChangeTimestampOffset) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
-  ASSERT_TRUE(demuxer_->SetTimestampOffset(kSourceId, kDefaultDuration()));
+  ASSERT_TRUE(demuxer_->SetTimestampOffset(kSourceId,
+                                           kDefaultDuration().InSecondsF()));
 
   EXPECT_CALL(host_, SetDuration(
       kDefaultDuration() + base::TimeDelta::FromMilliseconds(
           kAudioBlockDuration * 2)));
   AppendCluster(GenerateCluster(0, 4));
 }
 
 TEST_F(ChunkDemuxerTest, EndOfStreamTruncateDuration) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
@@ skipping 393 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 contiue to return expected values.
   CheckExpectedBuffers(audio_stream, "160 180");
   CheckExpectedBuffers(video_stream, "180 210");
 }
 
 }  // namespace media