Introduce the playback time into the MSE garbage collection.

media/filters/legacy_frame_processor.cc

 // 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.
 
 #include "media/filters/legacy_frame_processor.h"
 
 #include "media/base/buffers.h"
 #include "media/base/stream_parser_buffer.h"
 
 namespace media {
@@ skipping 15 matching lines @@
   sequence_mode_ = sequence_mode;
 }
 
 bool LegacyFrameProcessor::ProcessFrames(
     const StreamParser::BufferQueue& audio_buffers,
     const StreamParser::BufferQueue& video_buffers,
     const StreamParser::TextBufferQueueMap& text_map,
     base::TimeDelta append_window_start,
     base::TimeDelta append_window_end,
     bool* new_media_segment,
-    base::TimeDelta* timestamp_offset) {
+    base::TimeDelta* timestamp_offset,
+    base::TimeDelta media_time) {
   DVLOG(2) << __FUNCTION__ << "()";
   DCHECK(new_media_segment);
   DCHECK(timestamp_offset);
 
   // NOTE: Legacy coded frame processing does not update timestamp offset.
   base::TimeDelta offset = *timestamp_offset;
 
   DCHECK(!audio_buffers.empty() || !video_buffers.empty() ||
          !text_map.empty());
 
@@ skipping 57 matching lines @@
       segment_timestamp = std::min(filtered_video.front()->GetDecodeTimestamp(),
                                    segment_timestamp);
     }
 
     *new_media_segment = false;
     DCHECK(segment_timestamp != kInfiniteDuration());
     NotifyNewMediaSegmentStarting(segment_timestamp);
   }
 
   if (!filtered_audio.empty() &&
-      !AppendAndUpdateDuration(audio_track->stream(), filtered_audio)) {
+      !AppendAndUpdateDuration(
+          audio_track->stream(), filtered_audio, media_time)) {
     return false;
   }
 
   if (!filtered_video.empty() &&
-      !AppendAndUpdateDuration(video_track->stream(), filtered_video)) {
+      !AppendAndUpdateDuration(
+          video_track->stream(), filtered_video, media_time)) {
     return false;
   }
 
   if (!filtered_text.empty()) {
     for (StreamParser::TextBufferQueueMap::const_iterator itr =
              filtered_text.begin();
          itr != filtered_text.end();
          ++itr) {
       MseTrackBuffer* track = FindTrack(itr->first);
-      if (!track || !AppendAndUpdateDuration(track->stream(), itr->second))
+      if (!track || !AppendAndUpdateDuration(
+          track->stream(), itr->second, media_time))
         return false;
     }
   }
 
   return true;
 }
 
 void LegacyFrameProcessor::AdjustBufferTimestamps(
     const StreamParser::BufferQueue& buffers,
     base::TimeDelta timestamp_offset) {
@@ skipping 86 matching lines @@
 
       track->set_needs_random_access_point(false);
     }
 
     filtered_buffers->push_back(buffer);
   }
 }
 
 bool LegacyFrameProcessor::AppendAndUpdateDuration(
     ChunkDemuxerStream* stream,
-    const StreamParser::BufferQueue& buffers) {
+    const StreamParser::BufferQueue& buffers,
+    base::TimeDelta media_time) {
   DCHECK(!buffers.empty());
 
-  if (!stream || !stream->Append(buffers))
+  if (!stream || !stream->Append(buffers, media_time))
     return false;
 
   // Approximate spec's "highest presentation end timestamp".
   base::TimeDelta highest_end_timestamp = stream->GetBufferedDuration();
   DCHECK(highest_end_timestamp > base::TimeDelta());
 
   increase_duration_cb_.Run(highest_end_timestamp);
   return true;
 }
 
@@ skipping 29 matching lines @@
         std::min(*lowest_segment_timestamp,
                  filtered_buffers.front()->GetDecodeTimestamp());
     DCHECK(filtered_text->find(text_track_id) == filtered_text->end());
     filtered_text->insert(std::make_pair(text_track_id, filtered_buffers));
   }
 
   return true;
 }
 
 }  // namespace media