Fix ChunkDemuxer so it properly outputs buffered ranges.

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 "base/logging.h"
@@ skipping 68 matching lines @@
   // filled with a valid buffer, false if there is not enough data to fulfill
   // the request.
   bool GetNextBuffer(scoped_refptr<StreamParserBuffer>* out_buffer);
   bool HasNextBuffer() const;
 
   // Returns the timestamp of the next buffer that will be returned from
   // GetNextBuffer(). Returns kNoTimestamp() if Seek() has never been called or
   // if this range does not have the next buffer yet.
   base::TimeDelta GetNextTimestamp() const;
 
+  // Returns the start timestamp of the range.
+  base::TimeDelta GetStartTimestamp() const;
+
   // Returns the end timestamp of the buffered data. (Note that this is equal to
   // the last buffer's timestamp + its duration.)
   base::TimeDelta GetEndTimestamp() const;
 
-  // Returns the Timespan of buffered time in this range.
-  SourceBufferStream::Timespan GetBufferedTime() const;
-
   // Returns whether a buffer with a starting timestamp of |timestamp| would
   // belong in this range. This includes a buffer that would be appended to
   // the end of the range.
   // Returns 0 if |timestamp| is in this range, -1 if |timestamp| appears
   // before this range, or 1 if |timestamp| appears after this range.
   int BelongsToRange(base::TimeDelta timestamp) const;
 
   // Returns true if the range has enough data to seek to the specified
   // |timestamp|, false otherwise.
   bool CanSeekTo(base::TimeDelta timestamp) const;
 
   // Returns true if this range's buffered timespan completely overlaps the
   // buffered timespan of |range|.
   bool CompletelyOverlaps(const SourceBufferRange& range) const;
 
   // Returns true if the end of this range contains buffers that overlaps with
   // the beginning of |range|.
   bool EndOverlaps(const SourceBufferRange& range) const;
 
  private:
   // Helper method to delete buffers in |buffers_| starting from
   // |starting_point|, an iterator in |buffers_|.
   void DeleteAfter(const BufferQueue::iterator& starting_point,
                    BufferQueue* deleted_buffers,
                    BufferQueue::iterator* next_buffer);
 
-  // Returns the start timestamp of the range.
-  base::TimeDelta GetStartTimestamp() const;
-
   // An ordered list of buffers in this range.
   BufferQueue buffers_;
 
   // Maps keyframe timestamps to its index position in |buffers_|.
   typedef std::map<base::TimeDelta, size_t> KeyframeMap;
   KeyframeMap keyframe_map_;
 
   // Index into |buffers_| for the next buffer to be returned by
-  // GetBufferedTime(), set to -1 before Seek().
+  // GetNextBuffer(), set to -1 before Seek().
   int next_buffer_index_;
 
   // True if the range needs to wait for the next keyframe to be appended before
   // returning buffers from GetNextBuffer().
   bool waiting_for_keyframe_;
 
   // If |waiting_for_keyframe_| is true, this range will wait for the next
   // keyframe with timestamp >= |next_keyframe_timestamp_|.
   base::TimeDelta next_keyframe_timestamp_;
 
@@ skipping 12 matching lines @@
 
 }  // namespace media
 
 // Helper method that returns true if |ranges| is sorted in increasing order,
 // false otherwise.
 static bool IsRangeListSorted(
     const std::list<media::SourceBufferRange*>& ranges) {
   base::TimeDelta prev = media::kNoTimestamp();
   for (std::list<media::SourceBufferRange*>::const_iterator itr =
        ranges.begin(); itr != ranges.end(); itr++) {
-    media::SourceBufferStream::Timespan buffered = (*itr)->GetBufferedTime();
-    if (prev != media::kNoTimestamp() && prev >= buffered.first)
+    if (prev != media::kNoTimestamp() && prev >= (*itr)->GetStartTimestamp())
       return false;
-    prev = buffered.second;
+    prev = (*itr)->GetEndTimestamp();
   }
   return true;
 }
 
 // Comparison function for two Buffers based on timestamp.
 static bool BufferComparator(
     const scoped_refptr<media::StreamParserBuffer>& first,
     const scoped_refptr<media::StreamParserBuffer>& second) {
   return first->GetTimestamp() < second->GetTimestamp();
 }
@@ skipping 316 matching lines @@
 
   if (end_of_stream_ && (!selected_range_ ||
                          !selected_range_->HasNextBuffer())) {
     *out_buffer = StreamParserBuffer::CreateEOSBuffer();
     return true;
   }
 
   return selected_range_ && selected_range_->GetNextBuffer(out_buffer);
 }
 
-SourceBufferStream::TimespanList SourceBufferStream::GetBufferedTime() const {
-  TimespanList timespans;
+Ranges<base::TimeDelta> SourceBufferStream::GetBufferedTime() const {
+  Ranges<base::TimeDelta> ranges;
   for (RangeList::const_iterator itr = ranges_.begin();
        itr != ranges_.end(); itr++) {
-    timespans.push_back((*itr)->GetBufferedTime());
+    ranges.Add((*itr)->GetStartTimestamp(), (*itr)->GetEndTimestamp());
   }
-  return timespans;
+  return ranges;
 }
 
 void SourceBufferStream::EndOfStream() {
   DCHECK(CanEndOfStream());
   end_of_stream_ = true;
 }
 
 bool SourceBufferStream::CanEndOfStream() const {
   return ranges_.empty() || selected_range_ == ranges_.back();
 }
@@ skipping 173 matching lines @@
   DCHECK(!buffers_.empty());
 
   if (next_buffer_index_ >= static_cast<int>(buffers_.size()) ||
       next_buffer_index_ < 0 || waiting_for_keyframe_) {
     return kNoTimestamp();
   }
 
   return buffers_.at(next_buffer_index_)->GetTimestamp();
 }
 
-SourceBufferStream::Timespan
-SourceBufferRange::GetBufferedTime() const {
-  return std::make_pair(GetStartTimestamp(), GetEndTimestamp());
-}
-
 void SourceBufferRange::AppendToEnd(const SourceBufferRange& range,
                                     bool transfer_current_position) {
   DCHECK(CanAppendToEnd(range));
   DCHECK(!buffers_.empty());
 
   if (transfer_current_position)
     next_buffer_index_ = range.next_buffer_index_ + buffers_.size();
 
   AppendToEnd(range.buffers_);
 }
@@ skipping 45 matching lines @@
     start_timestamp = buffers_.front()->GetTimestamp();
   return start_timestamp;
 }
 
 base::TimeDelta SourceBufferRange::GetEndTimestamp() const {
   DCHECK(!buffers_.empty());
   return buffers_.back()->GetEndTimestamp();
 }
 
 }  // namespace media