Convert media constants to constexpr.

media/filters/frame_processor_unittest.cc

 // Copyright 2014 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 <map>
 #include <string>
 #include <vector>
@@ skipping 31 matching lines @@
  public:
   FrameProcessorTestCallbackHelper() {}
   virtual ~FrameProcessorTestCallbackHelper() {}
 
   MOCK_METHOD1(PossibleDurationIncrease, void(base::TimeDelta new_duration));
 
   // Helper that calls the mock method as well as does basic sanity checks on
   // |new_duration|.
   void OnPossibleDurationIncrease(base::TimeDelta new_duration) {
     PossibleDurationIncrease(new_duration);
-    ASSERT_NE(kNoTimestamp(), new_duration);
-    ASSERT_NE(kInfiniteDuration(), new_duration);
+    ASSERT_NE(kNoTimestamp, new_duration);
+    ASSERT_NE(kInfiniteDuration, new_duration);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FrameProcessorTestCallbackHelper);
 };
 
 // Test parameter determines indicates if the TEST_P instance is targeted for
 // sequence mode (if true), or segments mode (if false).
 class FrameProcessorTest : public testing::TestWithParam<bool> {
  protected:
   FrameProcessorTest()
       : frame_processor_(new FrameProcessor(
             base::Bind(
                 &FrameProcessorTestCallbackHelper::OnPossibleDurationIncrease,
                 base::Unretained(&callbacks_)),
             new MediaLog())),
-        append_window_end_(kInfiniteDuration()),
+        append_window_end_(kInfiniteDuration),
         frame_duration_(base::TimeDelta::FromMilliseconds(10)),
         audio_id_(FrameProcessor::kAudioTrackId),
         video_id_(FrameProcessor::kVideoTrackId) {}
 
   enum StreamFlags {
     HAS_AUDIO = 1 << 0,
     HAS_VIDEO = 1 << 1
   };
 
   void AddTestTracks(int stream_flags) {
@@ skipping 74 matching lines @@
     ASSERT_TRUE(frame_processor_->ProcessFrames(
         StringToBufferQueue(audio_timestamps, audio_id_, DemuxerStream::AUDIO),
         StringToBufferQueue(video_timestamps, video_id_, DemuxerStream::VIDEO),
         empty_text_buffers_, append_window_start_, append_window_end_,
         &timestamp_offset_));
   }
 
   void CheckExpectedRangesByTimestamp(ChunkDemuxerStream* stream,
                                       const std::string& expected) {
     // Note, DemuxerStream::TEXT streams return [0,duration (==infinity here))
-    Ranges<base::TimeDelta> r = stream->GetBufferedRanges(kInfiniteDuration());
+    Ranges<base::TimeDelta> r = stream->GetBufferedRanges(kInfiniteDuration);
 
     std::stringstream ss;
     ss << "{ ";
     for (size_t i = 0; i < r.size(); ++i) {
       int64_t start = r.start(i).InMilliseconds();
       int64_t end = r.end(i).InMilliseconds();
       ss << "[" << start << "," << end << ") ";
     }
     ss << "}";
     EXPECT_EQ(expected, ss.str());
@@ skipping 50 matching lines @@
 
       // Decode the original_time_in_ms from the buffer's data.
       double original_time_in_ms;
       ASSERT_EQ(sizeof(original_time_in_ms), last_read_buffer_->data_size());
       original_time_in_ms = *(reinterpret_cast<const double*>(
           last_read_buffer_->data()));
       if (original_time_in_ms != time_in_ms)
         ss << ":" << original_time_in_ms;
 
       // Detect full-discard preroll buffer.
-      if (last_read_buffer_->discard_padding().first == kInfiniteDuration() &&
+      if (last_read_buffer_->discard_padding().first == kInfiniteDuration &&
           last_read_buffer_->discard_padding().second.is_zero()) {
         ss << "P";
       }
     }
 
     EXPECT_EQ(expected, ss.str());
     CheckReadStalls(stream);
   }
 
   // TODO(wolenetz): Refactor to instead verify the expected signalling or lack
@@ skipping 641 matching lines @@
   StreamParserBuffer* last_read_parser_buffer =
       static_cast<StreamParserBuffer*>(last_read_buffer_.get());
   ASSERT_EQ(base::TimeDelta::FromMilliseconds(0),
             last_read_parser_buffer->preroll_buffer()->duration());
 }
 
 INSTANTIATE_TEST_CASE_P(SequenceMode, FrameProcessorTest, Values(true));
 INSTANTIATE_TEST_CASE_P(SegmentsMode, FrameProcessorTest, Values(false));
 
 }  // namespace media