Convert media constants to constexpr.

media/base/audio_discard_helper.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 "media/base/audio_discard_helper.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "media/base/audio_buffer.h"
 
 namespace media {
 
 static void WarnOnNonMonotonicTimestamps(base::TimeDelta last_timestamp,
                                          base::TimeDelta current_timestamp) {
-  if (last_timestamp == kNoTimestamp() || last_timestamp < current_timestamp)
+  if (last_timestamp == kNoTimestamp || last_timestamp < current_timestamp)
     return;
 
   const base::TimeDelta diff = current_timestamp - last_timestamp;
   DLOG(WARNING) << "Input timestamps are not monotonically increasing! "
                 << " ts " << current_timestamp.InMicroseconds() << " us"
                 << " diff " << diff.InMicroseconds() << " us";
 }
 
 AudioDiscardHelper::AudioDiscardHelper(int sample_rate, size_t decoder_delay)
     : sample_rate_(sample_rate),
       decoder_delay_(decoder_delay),
       timestamp_helper_(sample_rate_),
       discard_frames_(0),
-      last_input_timestamp_(kNoTimestamp()),
+      last_input_timestamp_(kNoTimestamp),
       delayed_discard_(false),
       delayed_end_discard_(0) {
   DCHECK_GT(sample_rate_, 0);
 }
 
 AudioDiscardHelper::~AudioDiscardHelper() {
 }
 
 size_t AudioDiscardHelper::TimeDeltaToFrames(base::TimeDelta duration) const {
   DCHECK(duration >= base::TimeDelta());
   return duration.InSecondsF() * sample_rate_ + 0.5;
 }
 
 void AudioDiscardHelper::Reset(size_t initial_discard) {
   discard_frames_ = initial_discard;
-  last_input_timestamp_ = kNoTimestamp();
-  timestamp_helper_.SetBaseTimestamp(kNoTimestamp());
+  last_input_timestamp_ = kNoTimestamp;
+  timestamp_helper_.SetBaseTimestamp(kNoTimestamp);
   delayed_discard_ = false;
   delayed_discard_padding_ = DecoderBuffer::DiscardPadding();
 }
 
 bool AudioDiscardHelper::ProcessBuffers(
     const scoped_refptr<DecoderBuffer>& encoded_buffer,
     const scoped_refptr<AudioBuffer>& decoded_buffer) {
   DCHECK(!encoded_buffer->end_of_stream());
-  DCHECK(encoded_buffer->timestamp() != kNoTimestamp());
+  DCHECK(encoded_buffer->timestamp() != kNoTimestamp);
 
   // Issue a debug warning when we see non-monotonic timestamps.  Only a warning
   // to allow chained OGG playback.
   WarnOnNonMonotonicTimestamps(last_input_timestamp_,
                                encoded_buffer->timestamp());
   last_input_timestamp_ = encoded_buffer->timestamp();
 
   // If this is the first buffer seen, setup the timestamp helper.
   const bool first_buffer = !initialized();
   if (first_buffer) {
@@ skipping 65 matching lines @@
 
   // Handle front discard padding.
   if (current_discard_padding.first > base::TimeDelta()) {
     const size_t decoded_frames = decoded_buffer->frame_count();
 
     // If a complete buffer discard is requested and there's no decoder delay,
     // just discard all remaining frames from this buffer.  With decoder delay
     // we have to estimate the correct number of frames to discard based on the
     // duration of the encoded buffer.
     const size_t start_frames_to_discard =
-        current_discard_padding.first == kInfiniteDuration()
+        current_discard_padding.first == kInfiniteDuration
             ? (decoder_delay_ > 0
                    ? TimeDeltaToFrames(encoded_buffer->duration())
                    : decoded_frames)
             : TimeDeltaToFrames(current_discard_padding.first);
 
     // Regardless of the timestamp on the encoded buffer, the corresponding
     // decoded output will appear |decoder_delay_| frames later.
     size_t discard_start = decoder_delay_;
     if (decoder_delay_ > 0) {
       // If we have a |decoder_delay_| and have already discarded frames from
@@ skipping 79 matching lines @@
   DVLOG(3) << __FUNCTION__ << " ts: " << timestamp_helper_.GetTimestamp()
            << " frames: " << decoded_buffer->frame_count();
 
   // Assign timestamp to the buffer.
   decoded_buffer->set_timestamp(timestamp_helper_.GetTimestamp());
   timestamp_helper_.AddFrames(decoded_buffer->frame_count());
   return true;
 }
 
 }  // namespace media