Convert media constants to constexpr.

media/formats/webm/webm_cluster_parser.h

 // 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.
 
 #ifndef MEDIA_FORMATS_WEBM_WEBM_CLUSTER_PARSER_H_
 #define MEDIA_FORMATS_WEBM_WEBM_CLUSTER_PARSER_H_
 
 #include <stdint.h>
 
 #include <deque>
@@ skipping 43 matching lines @@
     Track(int track_num,
           bool is_video,
           base::TimeDelta default_duration,
           const scoped_refptr<MediaLog>& media_log);
     Track(const Track& other);
     ~Track();
 
     int track_num() const { return track_num_; }
 
     // If a buffer is currently held aside pending duration calculation, returns
-    // its decode timestamp. Otherwise, returns kInfiniteDuration().
+    // its decode timestamp. Otherwise, returns kInfiniteDuration.
     DecodeTimestamp GetReadyUpperBound();
 
     // Prepares |ready_buffers_| for retrieval. Prior to calling,
     // |ready_buffers_| must be empty. Moves all |buffers_| with decode
     // timestamp before |before_timestamp| to |ready_buffers_|, preserving their
     // order.
     void ExtractReadyBuffers(const DecodeTimestamp before_timestamp);
 
     const BufferQueue& ready_buffers() const { return ready_buffers_; }
 
     // If |last_added_buffer_missing_duration_| is set, updates its duration
     // relative to |buffer|'s timestamp, and adds it to |buffers_| and unsets
     // |last_added_buffer_missing_duration_|. Then, if |buffer| is missing
     // duration, saves |buffer| into |last_added_buffer_missing_duration_|, or
     // otherwise adds |buffer| to |buffers_|.
     bool AddBuffer(const scoped_refptr<StreamParserBuffer>& buffer);
 
     // If |last_added_buffer_missing_duration_| is set, updates its duration to
-    // be non-kNoTimestamp() value of |estimated_next_frame_duration_| or a
+    // be non-kNoTimestamp value of |estimated_next_frame_duration_| or a
     // hard-coded default, then adds it to |buffers_| and unsets
     // |last_added_buffer_missing_duration_|. (This method helps stream parser
     // emit all buffers in a media segment before signaling end of segment.)
     void ApplyDurationEstimateIfNeeded();
 
     // Clears |ready_buffers_| (use ExtractReadyBuffers() to fill it again).
     // Leaves as-is |buffers_| and any possibly held-aside buffer that is
     // missing duration.
     void ClearReadyBuffers();
 
@@ skipping 30 matching lines @@
     scoped_refptr<StreamParserBuffer> last_added_buffer_missing_duration_;
 
     // Buffers in (decode) timestamp order that were previously parsed into and
     // extracted from |buffers_|. Buffers are moved from |buffers_| to
     // |ready_buffers_| by ExtractReadyBuffers() if they are below a specified
     // upper bound timestamp. Track users can therefore extract only those
     // parsed buffers which are "ready" for emission (all before some maximum
     // timestamp).
     BufferQueue ready_buffers_;
 
-    // If kNoTimestamp(), then |estimated_next_frame_duration_| will be used.
+    // If kNoTimestamp, then |estimated_next_frame_duration_| will be used.
     base::TimeDelta default_duration_;
 
-    // If kNoTimestamp(), then a default value will be used. This estimate is
+    // If kNoTimestamp, then a default value will be used. This estimate is
     // the maximum (for video), or minimum (for audio) duration seen so far for
-    // this track, and is used only if |default_duration_| is kNoTimestamp().
+    // this track, and is used only if |default_duration_| is kNoTimestamp.
     // TODO(chcunningham): Use maximum for audio too, adding checks to disable
     // splicing when these estimates are observed in SourceBufferStream.
     base::TimeDelta estimated_next_frame_duration_;
 
     scoped_refptr<MediaLog> media_log_;
   };
 
   typedef std::map<int, Track> TextTrackMap;
 
  public:
@@ skipping 82 matching lines @@
   // Resets the Track objects associated with each text track.
   void ResetTextTracks();
 
   // Clears the the ready buffers associated with each text track.
   void ClearTextTrackReadyBuffers();
 
   // Helper method for Get{Audio,Video,Text}Buffers() that recomputes
   // |ready_buffer_upper_bound_| and calls ExtractReadyBuffers() on each track.
   // If |cluster_ended_| is true, first applies duration estimate if needed for
   // |audio_| and |video_| and sets |ready_buffer_upper_bound_| to
-  // kInfiniteDuration(). Otherwise, sets |ready_buffer_upper_bound_| to the
+  // kInfiniteDuration. Otherwise, sets |ready_buffer_upper_bound_| to the
   // minimum upper bound across |audio_| and |video_|. (Text tracks can have no
   // buffers missing duration, so they are not involved in calculating the upper
   // bound.)
   // Parse() or Reset() must be called between calls to UpdateReadyBuffers() to
   // clear each track's ready buffers and to reset |ready_buffer_upper_bound_|
   // to kNoDecodeTimestamp().
   void UpdateReadyBuffers();
 
   // Search for the indicated track_num among the text tracks.  Returns NULL
   // if that track num is not a text track.
   Track* FindTextTrack(int track_num);
 
   // Attempts to read the duration from the encoded audio data, returning as
-  // TimeDelta or kNoTimestamp() if duration cannot be retrieved. This obviously
+  // TimeDelta or kNoTimestamp if duration cannot be retrieved. This obviously
   // violates layering rules, but is useful for MSE to know duration in cases
   // where it isn't explicitly given and cannot be calculated for Blocks at the
   // end of a Cluster (the next Cluster in playback-order may not be the next
   // Cluster we parse, so we can't simply use the delta of the first Block in
   // the next Cluster). Avoid calling if encrypted; may produce unexpected
   // output. See implementation for supported codecs.
   base::TimeDelta TryGetEncodedAudioDuration(const uint8_t* data, int size);
 
   // Reads Opus packet header to determine packet duration. Duration returned
-  // as TimeDelta or kNoTimestamp() upon failure to read duration from packet.
+  // as TimeDelta or kNoTimestamp upon failure to read duration from packet.
   base::TimeDelta ReadOpusDuration(const uint8_t* data, int size);
 
   // Tracks the number of MEDIA_LOGs made in process of reading encoded
   // duration. Useful to prevent log spam.
   int num_duration_errors_ = 0;
 
   double timecode_multiplier_;  // Multiplier used to convert timecodes into
                                 // microseconds.
   std::set<int64_t> ignored_tracks_;
   std::string audio_encryption_key_id_;
@@ skipping 29 matching lines @@
   // Subset of |text_track_map_| maintained by GetTextBuffers(), and cleared by
   // ClearTextTrackReadyBuffers(). Callers of GetTextBuffers() get a const-ref
   // to this member.
   TextBufferQueueMap text_buffers_map_;
 
   // Limits the range of buffers returned by Get{Audio,Video,Text}Buffers() to
   // this exclusive upper bound. Set to kNoDecodeTimestamp(), meaning not yet
   // calculated, by Reset() and Parse(). If kNoDecodeTimestamp(), then
   // Get{Audio,Video,Text}Buffers() will calculate it to be the minimum (decode)
   // timestamp across all tracks' |last_buffer_missing_duration_|, or
-  // kInfiniteDuration() if no buffers are currently missing duration.
+  // kInfiniteDuration if no buffers are currently missing duration.
   DecodeTimestamp ready_buffer_upper_bound_;
 
   scoped_refptr<MediaLog> media_log_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(WebMClusterParser);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FORMATS_WEBM_WEBM_CLUSTER_PARSER_H_