Convert media constants to constexpr.

media/base/audio_splicer_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 "media/base/audio_splicer.h"
 
 #include <memory>
 
 #include "base/macros.h"
 #include "media/base/audio_buffer.h"
@@ skipping 416 matching lines @@
   // for output.
   EXPECT_TRUE(AddInput(extra_pre_splice_buffer));
   VerifyNextBuffer(extra_pre_splice_buffer);
 
   // The splicer should be internally queuing input since |overlapped_buffer| is
   // part of the splice.
   EXPECT_TRUE(AddInput(overlapped_buffer));
   EXPECT_FALSE(splicer_.HasNextBuffer());
 
   // |overlapping_buffer| completes the splice.
-  splicer_.SetSpliceTimestamp(kNoTimestamp());
+  splicer_.SetSpliceTimestamp(kNoTimestamp);
   EXPECT_TRUE(AddInput(overlapping_buffer));
   ASSERT_TRUE(splicer_.HasNextBuffer());
 
   // Add one more buffer to make sure it's passed through untouched.
   scoped_refptr<AudioBuffer> extra_post_splice_buffer =
       GetNextInputBuffer(0.5f, kBufferSize);
   EXPECT_TRUE(AddInput(extra_post_splice_buffer));
 
   VerifyPreSpliceOutput(overlapped_buffer,
                         overlapping_buffer,
@@ skipping 55 matching lines @@
   scoped_refptr<AudioBuffer> overlapping_buffer =
       GetNextInputBuffer(0.0f, kCrossfadeSize / 3);
 
   // The splicer should be internally queuing input since |overlapped_buffer| is
   // part of the splice.
   EXPECT_TRUE(AddInput(overlapped_buffer));
   EXPECT_FALSE(splicer_.HasNextBuffer());
 
   // |overlapping_buffer| should not have enough data to complete the splice, so
   // ensure output is not available.
-  splicer_.SetSpliceTimestamp(kNoTimestamp());
+  splicer_.SetSpliceTimestamp(kNoTimestamp);
   EXPECT_TRUE(AddInput(overlapping_buffer));
   EXPECT_FALSE(splicer_.HasNextBuffer());
 
   // Now add an EOS buffer which should complete the splice.
   EXPECT_TRUE(AddInput(AudioBuffer::CreateEOSBuffer()));
 
   VerifyPreSpliceOutput(overlapped_buffer,
                         overlapping_buffer,
                         331,
                         base::TimeDelta::FromMicroseconds(7505));
@@ skipping 39 matching lines @@
   splicer_.SetSpliceTimestamp(input_timestamp_helper_.GetTimestamp());
   scoped_refptr<AudioBuffer> overlapping_buffer =
       GetNextInputBuffer(0.0f, kCrossfadeSize * 2);
 
   // The splicer should be internally queuing input since |overlapped_buffer| is
   // part of the splice.
   EXPECT_TRUE(AddInput(overlapped_buffer));
   EXPECT_FALSE(splicer_.HasNextBuffer());
 
   // |overlapping_buffer| completes the splice.
-  splicer_.SetSpliceTimestamp(kNoTimestamp());
+  splicer_.SetSpliceTimestamp(kNoTimestamp);
   EXPECT_TRUE(AddInput(overlapping_buffer));
 
   const int kExpectedPreSpliceSize = 55;
   const base::TimeDelta kExpectedPreSpliceDuration =
       base::TimeDelta::FromMicroseconds(1247);
   VerifyPreSpliceOutput(overlapped_buffer,
                         overlapping_buffer,
                         kExpectedPreSpliceSize,
                         kExpectedPreSpliceDuration);
   VerifyCrossfadeOutput(overlapped_buffer,
@@ skipping 45 matching lines @@
       GetNextInputBuffer(0.0f, kBufferSize);
   second_buffer->set_timestamp(kSpliceTimestamp);
 
   // The splicer should be internally queuing input since |first_buffer| is part
   // of the supposed splice.
   EXPECT_TRUE(AddInput(first_buffer));
   EXPECT_FALSE(splicer_.HasNextBuffer());
 
   // |second_buffer| should complete the supposed splice, so ensure output is
   // now available.
-  splicer_.SetSpliceTimestamp(kNoTimestamp());
+  splicer_.SetSpliceTimestamp(kNoTimestamp);
   EXPECT_TRUE(AddInput(second_buffer));
 
   VerifyNextBuffer(first_buffer);
   VerifyNextBuffer(second_buffer);
   EXPECT_FALSE(splicer_.HasNextBuffer());
 }
 
 // Test behavior when a splice frame is incorrectly marked and there is a gap
 // between whats in the pre splice and post splice.
 // +--------+
@@ skipping 20 matching lines @@
       GetNextInputBuffer(0.0f, kBufferSize);
 
   // The splicer should pass through the first buffer since it's not part of the
   // splice.
   EXPECT_TRUE(AddInput(first_buffer));
   VerifyNextBuffer(first_buffer);
 
   // Do not add |gap_buffer|.
 
   // |second_buffer| will complete the supposed splice.
-  splicer_.SetSpliceTimestamp(kNoTimestamp());
+  splicer_.SetSpliceTimestamp(kNoTimestamp);
   EXPECT_TRUE(AddInput(second_buffer));
 
   VerifyNextBuffer(gap_buffer);
   VerifyNextBuffer(second_buffer);
   EXPECT_FALSE(splicer_.HasNextBuffer());
 }
 
 // Test behavior when a splice frame is incorrectly marked and there is a gap
 // between what's in the pre splice and post splice that is too large to recover
 // from.
@@ skipping 21 matching lines @@
       GetNextInputBuffer(0.0f, kBufferSize);
 
   // The splicer should pass through the first buffer since it's not part of the
   // splice.
   EXPECT_TRUE(AddInput(first_buffer));
   VerifyNextBuffer(first_buffer);
 
   // Do not add |gap_buffer|.
 
   // |second_buffer| will complete the supposed splice.
-  splicer_.SetSpliceTimestamp(kNoTimestamp());
+  splicer_.SetSpliceTimestamp(kNoTimestamp);
   EXPECT_FALSE(AddInput(second_buffer));
 }
 
 // Ensure we don't crash when a splice frame is incorrectly marked such that the
 // splice timestamp has already passed when SetSpliceTimestamp() is called.
 // This can happen if the encoded timestamps are too far behind the decoded
 // timestamps.
 TEST_F(AudioSplicerTest, IncorrectlyMarkedPastSplice) {
   const int kBufferSize = 200;
 
   scoped_refptr<AudioBuffer> first_buffer =
       GetNextInputBuffer(1.0f, kBufferSize);
   EXPECT_TRUE(AddInput(first_buffer));
   VerifyNextBuffer(first_buffer);
 
   // Start the splice at a timestamp which has already occurred.
   splicer_.SetSpliceTimestamp(base::TimeDelta());
 
   scoped_refptr<AudioBuffer> second_buffer =
       GetNextInputBuffer(0.5f, kBufferSize);
   EXPECT_TRUE(AddInput(second_buffer));
   EXPECT_FALSE(splicer_.HasNextBuffer());
 
   // |third_buffer| will complete the supposed splice.  The buffer size is set
   // such that unchecked the splicer would try to trim off a negative number of
   // frames.
-  splicer_.SetSpliceTimestamp(kNoTimestamp());
+  splicer_.SetSpliceTimestamp(kNoTimestamp);
   scoped_refptr<AudioBuffer> third_buffer =
       GetNextInputBuffer(0.0f, kBufferSize * 10);
   third_buffer->set_timestamp(base::TimeDelta());
   EXPECT_TRUE(AddInput(third_buffer));
 
   // The second buffer should come through unmodified.
   VerifyNextBuffer(second_buffer);
 
   // The third buffer should be partially dropped since it overlaps the second.
   ASSERT_TRUE(splicer_.HasNextBuffer());
   const base::TimeDelta second_buffer_end_ts =
       second_buffer->timestamp() + second_buffer->duration();
   scoped_refptr<AudioBuffer> output = splicer_.GetNextBuffer();
   EXPECT_EQ(second_buffer_end_ts, output->timestamp());
   EXPECT_EQ(third_buffer->duration() -
                 (second_buffer_end_ts - third_buffer->timestamp()),
             output->duration());
   EXPECT_TRUE(VerifyData(output, GetValue(third_buffer)));
 }
 
 }  // namespace media