Introduce the playback time into the MSE garbage collection.

media/filters/source_buffer_stream.h

 // 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.
 
 // SourceBufferStream is a data structure that stores media Buffers in ranges.
 // Buffers can be appended out of presentation order. Buffers are retrieved by
 // seeking to the desired start point and calling GetNextBuffer(). Buffers are
 // returned in sequential presentation order.
 
 #ifndef MEDIA_FILTERS_SOURCE_BUFFER_STREAM_H_
@@ skipping 56 matching lines @@
   // Signals that the next buffers appended are part of a new media segment
   // starting at |media_segment_start_time|.
   void OnNewMediaSegment(base::TimeDelta media_segment_start_time);
 
   // Add the |buffers| to the SourceBufferStream. Buffers within the queue are
   // expected to be in order, but multiple calls to Append() may add buffers out
   // of order or overlapping. Assumes all buffers within |buffers| are in
   // presentation order and are non-overlapping.
   // Returns true if Append() was successful, false if |buffers| are not added.
   // TODO(vrk): Implement garbage collection. (crbug.com/125070)
-  bool Append(const BufferQueue& buffers);
+  bool Append(const BufferQueue& buffers,
+              base::TimeDelta media_time);
 
   // Removes buffers between |start| and |end| according to the steps
   // in the "Coded Frame Removal Algorithm" in the Media Source
   // Extensions Spec.
   // https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#sourcebuffer-coded-frame-removal
   //
   // |duration| is the current duration of the presentation. It is
   // required by the computation outlined in the spec.
   void Remove(base::TimeDelta start, base::TimeDelta end,
               base::TimeDelta duration);
 
+  // Update the playback time.
+  // This playback time is used to avoid garbage collecting buffers
+  // corresponding to the playback time:
+  // MSE spec - 2.4.4 SourceBuffer Monitoring.
+  void NotifyMediaTimeUpdate(base::TimeDelta media_time);
+
   // Changes the SourceBufferStream's state so that it will start returning
   // buffers starting from the closest keyframe before |timestamp|.
   void Seek(base::TimeDelta timestamp);
 
   // Returns true if the SourceBufferStream has seeked to a time without
   // buffered data and is waiting for more data to be appended.
   bool IsSeekPending() const;
 
   // Notifies the SourceBufferStream that the media duration has been changed to
   // |duration| so it should drop any data past that point.
@@ skipping 43 matching lines @@
   void set_memory_limit_for_testing(int memory_limit) {
     memory_limit_ = memory_limit;
   }
 
  private:
   friend class SourceBufferStreamTest;
 
   typedef std::list<SourceBufferRange*> RangeList;
 
   // Frees up space if the SourceBufferStream is taking up too much memory.
-  void GarbageCollectIfNeeded();
+  void GarbageCollectIfNeeded(base::TimeDelta media_time);
 
   // Attempts to delete approximately |total_bytes_to_free| amount of data
   // |ranges_|, starting at the front of |ranges_| and moving linearly forward
   // through the buffers. Deletes starting from the back if |reverse_direction|
   // is true. Returns the number of bytes freed.
-  int FreeBuffers(int total_bytes_to_free, bool reverse_direction);
+  int FreeBuffers(int total_bytes_to_free,
+                  bool reverse_direction,
+                  base::TimeDelta media_time);
 
   // Attempts to delete approximately |total_bytes_to_free| amount of data from
   // |ranges_|, starting after the last appended buffer before the current
   // playback position.
   int FreeBuffersAfterLastAppended(int total_bytes_to_free);
 
   // Gets the removal range to secure |byte_to_free| from
   // [|start_timestamp|, |end_timestamp|).
   // Returns the size of buffers to secure if future
   // Remove(|start_timestamp|, |removal_end_timestamp|, duration) is called.
@@ skipping 192 matching lines @@
   bool end_of_stream_;
 
   // Timestamp of the last request to Seek().
   base::TimeDelta seek_buffer_timestamp_;
 
   // Pointer to the seeked-to Range. This is the range from which
   // GetNextBuffer() calls are fulfilled after the |track_buffer_| has been
   // emptied.
   SourceBufferRange* selected_range_;
 
+  // Current media time.
+  // This does not need to be very accurate as long as it represents a lower
+  // bound of the media time.
+  base::TimeDelta current_media_time_;
+
   // Queue of the next buffers to be returned from calls to GetNextBuffer(). If
   // |track_buffer_| is empty, return buffers from |selected_range_|.
   BufferQueue track_buffer_;
 
   // The start time of the current media segment being appended.
   base::TimeDelta media_segment_start_time_;
 
   // Points to the range containing the current media segment being appended.
   RangeList::iterator range_for_next_append_;
 
@@ skipping 36 matching lines @@
 
   // Indicates that splice frame generation is enabled.
   const bool splice_frames_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(SourceBufferStream);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_SOURCE_BUFFER_STREAM_H_