Convert media constants to constexpr.

media/test/pipeline_integration_test.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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
@@ skipping 518 matching lines @@
   void set_demuxer_failure_cb(const PipelineStatusCB& demuxer_failure_cb) {
     demuxer_failure_cb_ = demuxer_failure_cb;
   }
 
   void Seek(base::TimeDelta seek_time,
             size_t new_position,
             size_t seek_append_size) {
     chunk_demuxer_->StartWaitingForSeek(seek_time);
 
     chunk_demuxer_->ResetParserState(kSourceId, base::TimeDelta(),
-                                     kInfiniteDuration(),
+                                     kInfiniteDuration,
                                      &last_timestamp_offset_);
 
     DCHECK_LT(new_position, file_data_->data_size());
     current_position_ = new_position;
 
     AppendData(seek_append_size);
   }
 
   void Seek(base::TimeDelta seek_time) {
     chunk_demuxer_->StartWaitingForSeek(seek_time);
   }
 
   void AppendData(size_t size) {
     DCHECK(chunk_demuxer_);
     DCHECK_LT(current_position_, file_data_->data_size());
     DCHECK_LE(current_position_ + size, file_data_->data_size());
 
     ASSERT_TRUE(chunk_demuxer_->AppendData(
         kSourceId, file_data_->data() + current_position_, size,
-        base::TimeDelta(), kInfiniteDuration(), &last_timestamp_offset_));
+        base::TimeDelta(), kInfiniteDuration, &last_timestamp_offset_));
     current_position_ += size;
   }
 
   bool AppendAtTime(base::TimeDelta timestamp_offset,
                     const uint8_t* pData,
                     int size) {
     CHECK(!chunk_demuxer_->IsParsingMediaSegment(kSourceId));
     bool success =
         chunk_demuxer_->AppendData(kSourceId, pData, size, base::TimeDelta(),
-                                   kInfiniteDuration(), &timestamp_offset);
+                                   kInfiniteDuration, &timestamp_offset);
     last_timestamp_offset_ = timestamp_offset;
     return success;
   }
 
   void AppendAtTimeWithWindow(base::TimeDelta timestamp_offset,
                               base::TimeDelta append_window_start,
                               base::TimeDelta append_window_end,
                               const uint8_t* pData,
                               int size) {
     CHECK(!chunk_demuxer_->IsParsingMediaSegment(kSourceId));
@@ skipping 15 matching lines @@
   void RemoveRange(base::TimeDelta start, base::TimeDelta end) {
     chunk_demuxer_->Remove(kSourceId, start, end);
   }
 
   void EndOfStream() { chunk_demuxer_->MarkEndOfStream(PIPELINE_OK); }
 
   void Shutdown() {
     if (!chunk_demuxer_)
       return;
     chunk_demuxer_->ResetParserState(kSourceId, base::TimeDelta(),
-                                     kInfiniteDuration(),
+                                     kInfiniteDuration,
                                      &last_timestamp_offset_);
     chunk_demuxer_->Shutdown();
     chunk_demuxer_ = NULL;
   }
 
   void DemuxerOpened() {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&MockMediaSource::DemuxerOpenedTask,
                               base::Unretained(this)));
   }
@@ skipping 883 matching lines @@
 
   // Trim off multiple frames off the beginning of the segment which will cause
   // the first decoded frame to be incorrect if preroll isn't implemented.
   const base::TimeDelta adts_preroll_duration =
       base::TimeDelta::FromSecondsD(2.5 * 1024 / 44100);
   const base::TimeDelta append_time =
       source.last_timestamp_offset() - adts_preroll_duration;
 
   scoped_refptr<DecoderBuffer> second_file = ReadTestDataFile("sfx.adts");
   source.AppendAtTimeWithWindow(
-      append_time, append_time + adts_preroll_duration, kInfiniteDuration(),
+      append_time, append_time + adts_preroll_duration, kInfiniteDuration,
       second_file->data(), second_file->data_size());
   source.EndOfStream();
 
   Play();
   EXPECT_TRUE(WaitUntilOnEnded());
 
   EXPECT_EQ(592, source.last_timestamp_offset().InMilliseconds());
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(592, pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
@@ skipping 111 matching lines @@
 
   // There are 576 silent frames at the start of this mp3.  The second append
   // should trim them off.
   const base::TimeDelta mp3_preroll_duration =
       base::TimeDelta::FromSecondsD(576.0 / 44100);
   const base::TimeDelta append_time =
       source.last_timestamp_offset() - mp3_preroll_duration;
 
   scoped_refptr<DecoderBuffer> second_file = ReadTestDataFile("sfx.mp3");
   source.AppendAtTimeWithWindow(append_time, append_time + mp3_preroll_duration,
-                                kInfiniteDuration(), second_file->data(),
+                                kInfiniteDuration, second_file->data(),
                                 second_file->data_size());
   source.EndOfStream();
 
   Play();
   EXPECT_TRUE(WaitUntilOnEnded());
 
   EXPECT_EQ(613, source.last_timestamp_offset().InMilliseconds());
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(613, pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
@@ skipping 748 matching lines @@
 
 TEST_F(PipelineIntegrationTest, BasicPlaybackPositiveStartTime) {
   ASSERT_EQ(PIPELINE_OK, Start("nonzero-start-time.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   ASSERT_EQ(base::TimeDelta::FromMicroseconds(396000),
             demuxer_->GetStartTime());
 }
 
 }  // namespace media