WIP - MSE: Drop non-keyframes that lack keyframe dependency

media/filters/chunk_demuxer.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/chunk_demuxer.h"
 
 #include <algorithm>
 #include <limits>
 #include <list>
 
@@ skipping 596 matching lines @@
 
       if (!audio_) {
         DVLOG(1) << "Failed to create an audio stream.";
         return false;
       }
 
       if (!frame_processor_->AddTrack(FrameProcessor::kAudioTrackId, audio_)) {
         DVLOG(1) << "Failed to add audio track to frame processor.";
         return false;
       }
+
+      audio_->UpdateRangeRemovalCB(
+          base::Bind(&FrameProcessor::OnRangeRemoval,
+                     base::Unretained(frame_processor_.get()),
+                     FrameProcessor::kAudioTrackId));
     }
 
     frame_processor_->OnPossibleAudioConfigUpdate(audio_config);
     success &= audio_->UpdateAudioConfig(audio_config, log_cb_);
   }
 
   if (video_config.IsValidConfig()) {
     if (!video_) {
       media_log_->SetBooleanProperty("found_video_stream", true);
     }
     if (!video_ ||
         video_->video_decoder_config().codec() != video_config.codec()) {
       media_log_->SetStringProperty("video_codec_name",
                                     video_config.GetHumanReadableCodecName());
     }
 
     if (!video_) {
       video_ = create_demuxer_stream_cb_.Run(DemuxerStream::VIDEO);
 
       if (!video_) {
         DVLOG(1) << "Failed to create a video stream.";
         return false;
       }
 
       if (!frame_processor_->AddTrack(FrameProcessor::kVideoTrackId, video_)) {
         DVLOG(1) << "Failed to add video track to frame processor.";
         return false;
       }
+
+      video_->UpdateRangeRemovalCB(
+          base::Bind(&FrameProcessor::OnRangeRemoval,
+                     base::Unretained(frame_processor_.get()),
+                     FrameProcessor::kVideoTrackId));
     }
 
     success &= video_->UpdateVideoConfig(video_config, log_cb_);
   }
 
   typedef StreamParser::TextTrackConfigMap::const_iterator TextConfigItr;
   if (text_stream_map_.empty()) {
     for (TextConfigItr itr = text_configs.begin();
          itr != text_configs.end(); ++itr) {
       ChunkDemuxerStream* const text_stream =
           create_demuxer_stream_cb_.Run(DemuxerStream::TEXT);
       if (!frame_processor_->AddTrack(itr->first, text_stream)) {
         success &= false;
         MEDIA_LOG(ERROR, log_cb_) << "Failed to add text track ID "
                                   << itr->first << " to frame processor.";
         break;
       }
+      text_stream->UpdateRangeRemovalCB(
+          base::Bind(&FrameProcessor::OnRangeRemoval,
+                     base::Unretained(frame_processor_.get()), itr->first));
       text_stream->UpdateTextConfig(itr->second, log_cb_);
       text_stream_map_[itr->first] = text_stream;
       new_text_track_cb_.Run(text_stream, itr->second);
     }
   } else {
     const size_t text_count = text_stream_map_.size();
     if (text_configs.size() != text_count) {
       success &= false;
       MEDIA_LOG(ERROR, log_cb_) << "The number of text track configs changed.";
     } else if (text_count == 1) {
       TextConfigItr config_itr = text_configs.begin();
       TextStreamMap::iterator stream_itr = text_stream_map_.begin();
       ChunkDemuxerStream* text_stream = stream_itr->second;
       TextTrackConfig old_config = text_stream->text_track_config();
       TextTrackConfig new_config(config_itr->second.kind(),
                                  config_itr->second.label(),
                                  config_itr->second.language(),
                                  old_config.id());
       if (!new_config.Matches(old_config)) {
         success &= false;
         MEDIA_LOG(ERROR, log_cb_)
             << "New text track config does not match old one.";
       } else {
         StreamParser::TrackId old_id = stream_itr->first;
         StreamParser::TrackId new_id = config_itr->first;
         if (new_id != old_id) {
           if (frame_processor_->UpdateTrack(old_id, new_id)) {
+            text_stream->UpdateRangeRemovalCB(
+                base::Bind(&FrameProcessor::OnRangeRemoval,
+                           base::Unretained(frame_processor_.get()), new_id));
             text_stream_map_.clear();
-            text_stream_map_[config_itr->first] = text_stream;
+            text_stream_map_[new_id] = text_stream;
           } else {
             success &= false;
             MEDIA_LOG(ERROR, log_cb_)
                 << "Error remapping single text track number";
           }
         }
       }
     } else {
       for (TextConfigItr config_itr = text_configs.begin();
            config_itr != text_configs.end(); ++config_itr) {
@@ skipping 268 matching lines @@
 
 void ChunkDemuxerStream::UpdateTextConfig(const TextTrackConfig& config,
                                           const LogCB& log_cb) {
   DCHECK_EQ(type_, TEXT);
   base::AutoLock auto_lock(lock_);
   DCHECK(!stream_);
   DCHECK_EQ(state_, UNINITIALIZED);
   stream_.reset(new SourceBufferStream(config, log_cb, splice_frames_enabled_));
 }
 
+void ChunkDemuxerStream::UpdateRangeRemovalCB(
+    const SourceBufferStream::NotifyRangeRemovalCB& range_removal_cb) {
+  DCHECK(!range_removal_cb.is_null());
+  base::AutoLock auto_lock(lock_);
+  stream_->set_range_removal_cb(range_removal_cb);
+}
+
 void ChunkDemuxerStream::MarkEndOfStream() {
   base::AutoLock auto_lock(lock_);
   stream_->MarkEndOfStream();
 }
 
 void ChunkDemuxerStream::UnmarkEndOfStream() {
   base::AutoLock auto_lock(lock_);
   stream_->UnmarkEndOfStream();
 }
 
@@ skipping 851 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media