Clean up comments and style of SourceBufferRange header

media/filters/source_buffer_range.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_FILTERS_SOURCE_BUFFER_RANGE_H_
 #define MEDIA_FILTERS_SOURCE_BUFFER_RANGE_H_
 
 #include <stddef.h>
 
 #include <map>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "media/base/stream_parser_buffer.h"
 
 namespace media {
 
-// Helper class representing a range of buffered data. All buffers in a
-// SourceBufferRange are ordered sequentially in decode timestamp order with no
-// gaps.
+// Helper class representing a continuous range of buffered data in the
+// presentation timeline. All buffers in a SourceBufferRange are ordered
+// sequentially in decode timestamp order with no gaps.
 class SourceBufferRange {
  public:
-  // Returns the maximum distance in time between any buffer seen in this
-  // stream. Used to estimate the duration of a buffer if its duration is not
-  // known.
+  // Returns the maximum distance in time between any buffer seen in the stream
+  // of which this range is a part. Used to estimate the duration of a buffer if
+  // its duration is not known, and in GetFudgeRoom() for determining whether a
+  // time or coded frame is close enough to be considered part of this range.
   typedef base::Callback<base::TimeDelta()> InterbufferDistanceCB;
 
   typedef StreamParser::BufferQueue BufferQueue;
 
   // Policy for handling large gaps between buffers. Continuous media like
   // audio & video should use NO_GAPS_ALLOWED. Discontinuous media like
   // timed text should use ALLOW_GAPS because large differences in timestamps
   // are common and acceptable.
   enum GapPolicy {
     NO_GAPS_ALLOWED,
     ALLOW_GAPS
   };
 
-  // Return the config ID for the buffer at |timestamp|. Precondition: callers
-  // must first verify CanSeekTo(timestamp) == true.
-  int GetConfigIdAtTime(DecodeTimestamp timestamp);
-
-  // Return true if all buffers in range of [start, end] have the same config
-  // ID. Precondition: callers must first verify that
-  // CanSeekTo(start) ==  CanSeekTo(end) == true.
-  bool SameConfigThruRange(DecodeTimestamp start, DecodeTimestamp end);
-
   // Sequential buffers with the same decode timestamp make sense under certain
   // conditions, typically when the first buffer is a keyframe. Due to some
   // atypical media append behaviors where a new keyframe might have the same
-  // timestamp as a previous non-keyframe, the playback of the sequence might
-  // involve some throwaway decode work. This method supports detecting this
-  // situation so that callers can log warnings (it returns true in this case
-  // only).
+  // decode timestamp as a previous non-keyframe, the playback of the sequence
+  // might involve some throwaway decode work. This method supports detecting
+  // this situation so that callers can log warnings (it returns true in this
+  // case only).
   // For all other cases, including more typical same-DTS sequences, this method
   // returns false. Examples of typical situations where DTS of two consecutive
   // frames can be equal:
   // - Video: VP8 Alt-Ref frames.
   // - Video: IPBPBP...: DTS for I frame and for P frame can be equal.
   // - Text track cues that start at same time.
   // Returns true if |prev_is_keyframe| and |current_is_keyframe| indicate a
   // same timestamp situation that is atypical. False is returned otherwise.
   static bool IsUncommonSameTimestampSequence(bool prev_is_keyframe,
                                               bool current_is_keyframe);
@@ skipping 34 matching lines @@
   // timestamp must be adjacent to this range. No group start timestamp
   // adjacency is involved in these methods.
   void AppendRangeToEnd(const SourceBufferRange& range,
                         bool transfer_current_position);
   bool CanAppendRangeToEnd(const SourceBufferRange& range) const;
 
   // Updates |next_buffer_index_| to point to the Buffer containing |timestamp|.
   // Assumes |timestamp| is valid and in this range.
   void Seek(DecodeTimestamp timestamp);
 
+  // Return the config ID for the buffer at |timestamp|. Precondition: callers
+  // must first verify CanSeekTo(timestamp) == true.
+  int GetConfigIdAtTime(DecodeTimestamp timestamp);
+
+  // Return true if all buffers in range of [start, end] have the same config
+  // ID. Precondition: callers must first verify that
+  // CanSeekTo(start) ==  CanSeekTo(end) == true.
+  bool SameConfigThruRange(DecodeTimestamp start, DecodeTimestamp end);
+
   // Updates |next_buffer_index_| to point to next keyframe after or equal to
   // |timestamp|.
   void SeekAheadTo(DecodeTimestamp timestamp);
 
   // Updates |next_buffer_index_| to point to next keyframe strictly after
   // |timestamp|.
   void SeekAheadPast(DecodeTimestamp timestamp);
 
   // Seeks to the beginning of the range.
   void SeekToStart();
@@ skipping 205 matching lines @@
 
   // Stores the amount of memory taken up by the data in |buffers_|.
   size_t size_in_bytes_;
 
   DISALLOW_COPY_AND_ASSIGN(SourceBufferRange);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_SOURCE_BUFFER_RANGE_H_