Convert media constants to constexpr.

media/filters/source_buffer_stream.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/filters/source_buffer_stream.h"
 
 #include <algorithm>
 #include <map>
 #include <sstream>
 
@@ skipping 127 matching lines @@
   NOTREACHED();
   return SourceBufferRange::NO_GAPS_ALLOWED;
 }
 
 }  // namespace
 
 SourceBufferStream::SourceBufferStream(const AudioDecoderConfig& audio_config,
                                        const scoped_refptr<MediaLog>& media_log,
                                        bool splice_frames_enabled)
     : media_log_(media_log),
-      seek_buffer_timestamp_(kNoTimestamp()),
+      seek_buffer_timestamp_(kNoTimestamp),
       coded_frame_group_start_time_(kNoDecodeTimestamp()),
       range_for_next_append_(ranges_.end()),
       last_output_buffer_timestamp_(kNoDecodeTimestamp()),
-      max_interbuffer_distance_(kNoTimestamp()),
+      max_interbuffer_distance_(kNoTimestamp),
       memory_limit_(kSourceBufferAudioMemoryLimit),
       splice_frames_enabled_(splice_frames_enabled) {
   DCHECK(audio_config.IsValidConfig());
   audio_configs_.push_back(audio_config);
 }
 
 SourceBufferStream::SourceBufferStream(const VideoDecoderConfig& video_config,
                                        const scoped_refptr<MediaLog>& media_log,
                                        bool splice_frames_enabled)
     : media_log_(media_log),
-      seek_buffer_timestamp_(kNoTimestamp()),
+      seek_buffer_timestamp_(kNoTimestamp),
       coded_frame_group_start_time_(kNoDecodeTimestamp()),
       range_for_next_append_(ranges_.end()),
       last_output_buffer_timestamp_(kNoDecodeTimestamp()),
-      max_interbuffer_distance_(kNoTimestamp()),
+      max_interbuffer_distance_(kNoTimestamp),
       memory_limit_(kSourceBufferVideoMemoryLimit),
       splice_frames_enabled_(splice_frames_enabled) {
   DCHECK(video_config.IsValidConfig());
   video_configs_.push_back(video_config);
 }
 
 SourceBufferStream::SourceBufferStream(const TextTrackConfig& text_config,
                                        const scoped_refptr<MediaLog>& media_log,
                                        bool splice_frames_enabled)
     : media_log_(media_log),
       text_track_config_(text_config),
-      seek_buffer_timestamp_(kNoTimestamp()),
+      seek_buffer_timestamp_(kNoTimestamp),
       coded_frame_group_start_time_(kNoDecodeTimestamp()),
       range_for_next_append_(ranges_.end()),
       last_output_buffer_timestamp_(kNoDecodeTimestamp()),
-      max_interbuffer_distance_(kNoTimestamp()),
+      max_interbuffer_distance_(kNoTimestamp),
       memory_limit_(kSourceBufferAudioMemoryLimit),
       splice_frames_enabled_(splice_frames_enabled) {}
 
 SourceBufferStream::~SourceBufferStream() {
   while (!ranges_.empty()) {
     delete ranges_.front();
     ranges_.pop_front();
   }
 }
 
 void SourceBufferStream::OnStartOfCodedFrameGroup(
     DecodeTimestamp coded_frame_group_start_time) {
   DVLOG(1) << __FUNCTION__ << " " << GetStreamTypeName() << " ("
            << coded_frame_group_start_time.InSecondsF() << ")";
   DCHECK(!end_of_stream_);
   coded_frame_group_start_time_ = coded_frame_group_start_time;
   new_coded_frame_group_ = true;
 
   RangeList::iterator last_range = range_for_next_append_;
   range_for_next_append_ = FindExistingRangeFor(coded_frame_group_start_time);
 
   // Only reset |last_appended_buffer_timestamp_| if this new coded frame group
   // is not adjacent to the previous coded frame group appended to the stream.
   if (range_for_next_append_ == ranges_.end() ||
       !AreAdjacentInSequence(last_appended_buffer_timestamp_,
                              coded_frame_group_start_time)) {
     last_appended_buffer_timestamp_ = kNoDecodeTimestamp();
-    last_appended_buffer_duration_ = kNoTimestamp();
+    last_appended_buffer_duration_ = kNoTimestamp;
     last_appended_buffer_is_keyframe_ = false;
     DVLOG(3) << __FUNCTION__ << " next appended buffers will "
              << (range_for_next_append_ == ranges_.end()
                      ? "be in a new range"
                      : "overlap an existing range");
   } else if (last_range != ranges_.end()) {
     DCHECK(last_range == range_for_next_append_);
     DVLOG(3) << __FUNCTION__ << " next appended buffers will continue range "
              << "unless intervening remove makes discontinuity";
   }
@@ skipping 172 matching lines @@
 }
 
 void SourceBufferStream::Remove(base::TimeDelta start, base::TimeDelta end,
                                 base::TimeDelta duration) {
   DVLOG(1) << __FUNCTION__ << " " << GetStreamTypeName()
            << " (" << start.InSecondsF() << ", " << end.InSecondsF()
            << ", " << duration.InSecondsF() << ")";
   DCHECK(start >= base::TimeDelta()) << start.InSecondsF();
   DCHECK(start < end) << "start " << start.InSecondsF()
                       << " end " << end.InSecondsF();
-  DCHECK(duration != kNoTimestamp());
+  DCHECK(duration != kNoTimestamp);
 
   DecodeTimestamp start_dts = DecodeTimestamp::FromPresentationTime(start);
   DecodeTimestamp end_dts = DecodeTimestamp::FromPresentationTime(end);
   DecodeTimestamp remove_end_timestamp =
       DecodeTimestamp::FromPresentationTime(duration);
   DecodeTimestamp keyframe_timestamp = FindKeyframeAfterTimestamp(end_dts);
   if (keyframe_timestamp != kNoDecodeTimestamp()) {
     remove_end_timestamp = keyframe_timestamp;
   } else if (end_dts < remove_end_timestamp) {
     remove_end_timestamp = end_dts;
@@ skipping 218 matching lines @@
 
     base::TimeDelta interbuffer_distance = (*itr)->duration();
     DCHECK(interbuffer_distance >= base::TimeDelta());
 
     if (prev_timestamp != kNoDecodeTimestamp()) {
       interbuffer_distance =
           std::max(current_timestamp - prev_timestamp, interbuffer_distance);
     }
 
     if (interbuffer_distance > base::TimeDelta()) {
-      if (max_interbuffer_distance_ == kNoTimestamp()) {
+      if (max_interbuffer_distance_ == kNoTimestamp) {
         max_interbuffer_distance_ = interbuffer_distance;
       } else {
         max_interbuffer_distance_ =
             std::max(max_interbuffer_distance_, interbuffer_distance);
       }
     }
     prev_timestamp = current_timestamp;
   }
 }
 
@@ skipping 61 matching lines @@
              << "] clamping media_time to be "
              << selected_buffered_end.InSecondsF();
     media_time = selected_buffered_end;
   }
 
   size_t bytes_freed = 0;
 
   // If last appended buffer position was earlier than the current playback time
   // then try deleting data between last append and current media_time.
   if (last_appended_buffer_timestamp_ != kNoDecodeTimestamp() &&
-      last_appended_buffer_duration_ != kNoTimestamp() &&
+      last_appended_buffer_duration_ != kNoTimestamp &&
       media_time >
           last_appended_buffer_timestamp_ + last_appended_buffer_duration_) {
     size_t between = FreeBuffersAfterLastAppended(bytes_to_free, media_time);
     DVLOG(3) << __FUNCTION__ << " FreeBuffersAfterLastAppended "
              << " released " << between << " bytes"
              << " ranges_=" << RangesToString(ranges_);
     bytes_freed += between;
 
     // Some players start appending data at the new seek target position before
     // actually initiating the seek operation (i.e. they try to improve seek
@@ skipping 272 matching lines @@
     // was generated.
     DCHECK(coded_frame_group_start_time_ != kNoDecodeTimestamp());
     start = std::min(coded_frame_group_start_time_, start);
   }
   DecodeTimestamp end = new_buffers.back()->GetDecodeTimestamp();
   base::TimeDelta duration = new_buffers.back()->duration();
 
   // Set end time for remove to include the duration of last buffer. If the
   // duration is estimated, use 1 microsecond instead to ensure frames are not
   // accidentally removed due to over-estimation.
-  if (duration != kNoTimestamp() && duration > base::TimeDelta() &&
+  if (duration != kNoTimestamp && duration > base::TimeDelta() &&
       !new_buffers.back()->is_duration_estimated()) {
     end += duration;
   } else {
     // TODO(chcunningham): Emit warning when 0ms durations are not expected.
     // http://crbug.com/312836
     end += base::TimeDelta::FromInternalValue(1);
   }
 
   RemoveInternal(start, end, exclude_start, deleted_buffers);
 }
@@ skipping 188 matching lines @@
     DVLOG(1) << "Config change (forced for fade in of splice frame).";
     return SourceBufferStream::kConfigChange;
   }
 
   // All pre-splice buffers have been handed out and a config change completed,
   // so hand out the final buffer for fade in.  Because a config change is
   // always issued prior to handing out this buffer, any changes in config id
   // have been inherently handled.
   DCHECK(pending_buffers_complete_);
   DCHECK_EQ(splice_buffers_index_, splice_buffers.size() - 1);
-  DCHECK(splice_buffers.back()->splice_timestamp() == kNoTimestamp());
+  DCHECK(splice_buffers.back()->splice_timestamp() == kNoTimestamp);
   *out_buffer = splice_buffers.back();
   pending_buffer_ = NULL;
 
   // If the last splice buffer has preroll, hand off to the preroll handler.
   return SetPendingBuffer(out_buffer) ? HandleNextBufferWithPreroll(out_buffer)
                                       : SourceBufferStream::kSuccess;
 }
 
 SourceBufferStream::Status SourceBufferStream::HandleNextBufferWithPreroll(
     scoped_refptr<StreamParserBuffer>* out_buffer) {
@@ skipping 225 matching lines @@
   if (config_change_pending_)
     CompleteConfigChange();
   return video_configs_[current_config_index_];
 }
 
 const TextTrackConfig& SourceBufferStream::GetCurrentTextTrackConfig() {
   return text_track_config_;
 }
 
 base::TimeDelta SourceBufferStream::GetMaxInterbufferDistance() const {
-  if (max_interbuffer_distance_ == kNoTimestamp())
+  if (max_interbuffer_distance_ == kNoTimestamp)
     return base::TimeDelta::FromMilliseconds(kDefaultBufferDurationInMs);
   return max_interbuffer_distance_;
 }
 
 bool SourceBufferStream::UpdateAudioConfig(const AudioDecoderConfig& config) {
   DCHECK(!audio_configs_.empty());
   DCHECK(video_configs_.empty());
   DVLOG(3) << "UpdateAudioConfig.";
 
   if (audio_configs_[0].codec() != config.codec()) {
@@ skipping 329 matching lines @@
     return false;
 
   DCHECK_NE(have_splice_buffers, have_preroll_buffer);
   splice_buffers_index_ = 0;
   pending_buffer_.swap(*out_buffer);
   pending_buffers_complete_ = false;
   return true;
 }
 
 }  // namespace media