Make ChunkDemuxer::SetTimestampOffset take a TimeDelta instead of double

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 "base/message_loop.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"
@@ skipping 2178 matching lines @@
                  NewExpectedStatusCB(PIPELINE_OK));
 
   // Verify that no config change is signalled.
   ExpectRead(stream, 801);
   ASSERT_TRUE(video_config_1.Matches(stream->video_decoder_config()));
 }
 
 TEST_F(ChunkDemuxerTest, TestTimestampPositiveOffset) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
-  ASSERT_TRUE(demuxer_->SetTimestampOffset(kSourceId, 30));
+  ASSERT_TRUE(demuxer_->SetTimestampOffset(
+      kSourceId, base::TimeDelta::FromSeconds(30)));
   scoped_ptr<Cluster> cluster(GenerateCluster(0, 2));
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
   GenerateExpectedReads(30000, 2, audio, video);
 }
 
 TEST_F(ChunkDemuxerTest, TestTimestampNegativeOffset) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
-  ASSERT_TRUE(demuxer_->SetTimestampOffset(kSourceId, -1));
+  ASSERT_TRUE(demuxer_->SetTimestampOffset(
+      kSourceId, base::TimeDelta::FromSeconds(-1)));
   scoped_ptr<Cluster> cluster = GenerateCluster(1000, 2);
   ASSERT_TRUE(AppendData(cluster->data(), cluster->size()));
 
   scoped_refptr<DemuxerStream> audio =
       demuxer_->GetStream(DemuxerStream::AUDIO);
   scoped_refptr<DemuxerStream> video =
       demuxer_->GetStream(DemuxerStream::VIDEO);
   GenerateExpectedReads(0, 2, audio, video);
 }
 
@@ skipping 18 matching lines @@
           kVideoBlockDuration));
 
   scoped_ptr<Cluster> cluster_a2(
       GenerateSingleStreamCluster(
           0, kAudioBlockDuration * 4, kAudioTrackNum, kAudioBlockDuration));
 
   scoped_ptr<Cluster> cluster_v2(
       GenerateSingleStreamCluster(
           0, kVideoBlockDuration * 4, kVideoTrackNum, kVideoBlockDuration));
 
-  ASSERT_TRUE(demuxer_->SetTimestampOffset(audio_id, -2.5));
-  ASSERT_TRUE(demuxer_->SetTimestampOffset(video_id, -2.5));
+  ASSERT_TRUE(demuxer_->SetTimestampOffset(
+      audio_id, base::TimeDelta::FromMilliseconds(-2500)));
+  ASSERT_TRUE(demuxer_->SetTimestampOffset(
+      video_id, base::TimeDelta::FromMilliseconds(-2500)));
   ASSERT_TRUE(AppendData(audio_id, cluster_a1->data(), cluster_a1->size()));
   ASSERT_TRUE(AppendData(video_id, cluster_v1->data(), cluster_v1->size()));
   GenerateSingleStreamExpectedReads(0, 4, audio, kAudioBlockDuration);
   GenerateSingleStreamExpectedReads(0, 4, video, kVideoBlockDuration);
 
   demuxer_->StartWaitingForSeek();
   demuxer_->Seek(base::TimeDelta::FromMilliseconds(27300),
                  NewExpectedStatusCB(PIPELINE_OK));
 
-  ASSERT_TRUE(demuxer_->SetTimestampOffset(audio_id, 27.3));
-  ASSERT_TRUE(demuxer_->SetTimestampOffset(video_id, 27.3));
+  ASSERT_TRUE(demuxer_->SetTimestampOffset(
+      audio_id, base::TimeDelta::FromMilliseconds(27300)));
+  ASSERT_TRUE(demuxer_->SetTimestampOffset(
+      video_id, base::TimeDelta::FromMilliseconds(27300)));
   ASSERT_TRUE(AppendData(audio_id, cluster_a2->data(), cluster_a2->size()));
   ASSERT_TRUE(AppendData(video_id, cluster_v2->data(), cluster_v2->size()));
   GenerateSingleStreamExpectedReads(27300, 4, video, kVideoBlockDuration);
   GenerateSingleStreamExpectedReads(27300, 4, audio, kAudioBlockDuration);
 }
 
 TEST_F(ChunkDemuxerTest, TestTimestampOffsetMidParse) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
   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));
+  ASSERT_FALSE(demuxer_->SetTimestampOffset(
+      kSourceId, base::TimeDelta::FromSeconds(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(
       kStreamDuration - kAudioBlockDuration,
       kStreamDuration - kVideoBlockDuration, 2);
@@ skipping 19 matching lines @@
       base::TimeDelta::FromMilliseconds(kNewStreamDuration)));
   ASSERT_TRUE(AppendData(third_cluster->data(), third_cluster->size()));
 
   // See that the range has increased appropriately.
   CheckExpectedRanges(kSourceId, "{ [201191,201270) }");
 }
 
 TEST_F(ChunkDemuxerTest, TestDurationChangeTimestampOffset) {
   ASSERT_TRUE(InitDemuxer(true, true, false));
 
-  ASSERT_TRUE(demuxer_->SetTimestampOffset(kSourceId,
-                                           kDefaultDuration().InSecondsF()));
+  ASSERT_TRUE(demuxer_->SetTimestampOffset(kSourceId, kDefaultDuration()));
   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(kDefaultFirstClusterEndTimestamp)));
   demuxer_->EndOfStream(PIPELINE_OK);
 }
 
 }  // namespace media