Experiment with more aggressive MSE GC on memory pressure

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 <utility>
 
@@ skipping 102 matching lines @@
   return true;
 }
 
 void ChunkDemuxerStream::Remove(TimeDelta start, TimeDelta end,
                                 TimeDelta duration) {
   base::AutoLock auto_lock(lock_);
   stream_->Remove(start, end, duration);
 }
 
 bool ChunkDemuxerStream::EvictCodedFrames(DecodeTimestamp media_time,
-                                          size_t newDataSize) {
+                                          size_t eviction_size,
+                                          size_t* bytes_released) {
   base::AutoLock auto_lock(lock_);
-  return stream_->GarbageCollectIfNeeded(media_time, newDataSize);
+  return stream_->GarbageCollectIfNeeded(media_time, eviction_size,
+                                         bytes_released);
 }
 
 void ChunkDemuxerStream::OnSetDuration(TimeDelta duration) {
   base::AutoLock auto_lock(lock_);
   stream_->OnSetDuration(duration);
 }
 
 Ranges<TimeDelta> ChunkDemuxerStream::GetBufferedRanges(
     TimeDelta duration) const {
   base::AutoLock auto_lock(lock_);
@@ skipping 175 matching lines @@
 TextTrackConfig ChunkDemuxerStream::text_track_config() {
   CHECK_EQ(type_, TEXT);
   base::AutoLock auto_lock(lock_);
   return stream_->GetCurrentTextTrackConfig();
 }
 
 void ChunkDemuxerStream::SetStreamMemoryLimit(size_t memory_limit) {
   stream_->set_memory_limit(memory_limit);
 }
 
+size_t ChunkDemuxerStream::stream_memory_limit() const {
+  DCHECK(stream_);
+  return stream_->memory_limit();
+}
+
 void ChunkDemuxerStream::SetLiveness(Liveness liveness) {
   base::AutoLock auto_lock(lock_);
   liveness_ = liveness;
 }
 
 void ChunkDemuxerStream::ChangeState_Locked(State state) {
   lock_.AssertAcquired();
   DVLOG(1) << "ChunkDemuxerStream::ChangeState_Locked() : "
            << "type " << type_
            << " - " << state_ << " -> " << state;
@@ skipping 398 matching lines @@
       DCHECK_EQ(DemuxerStream::VIDEO, stream->type());
       stream->set_enabled(false, currTime);
     }
   }
   if (selected_stream) {
     DVLOG(1) << __func__ << ": enabling stream " << selected_stream;
     selected_stream->set_enabled(true, currTime);
   }
 }
 
+void ChunkDemuxer::OnMemoryPressure(
+    base::TimeDelta currentMediaTime,
+    base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
+  if (memory_pressure_level <
+      base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE)
+    return;
+
+  DecodeTimestamp media_time_dts =
+      DecodeTimestamp::FromPresentationTime(currentMediaTime);
+  base::AutoLock auto_lock(lock_);
+  for (const auto& itr : source_state_map_) {
+    itr.second->OnMemoryPressure(media_time_dts, memory_pressure_level);
+  }
+}
+
 bool ChunkDemuxer::EvictCodedFrames(const std::string& id,
                                     base::TimeDelta currentMediaTime,
-                                    size_t newDataSize) {
+                                    size_t eviction_size) {
   DVLOG(1) << __func__ << "(" << id << ")"
            << " media_time=" << currentMediaTime.InSecondsF()
-           << " newDataSize=" << newDataSize;
+           << " eviction_size=" << eviction_size;
   base::AutoLock auto_lock(lock_);
 
   // Note: The direct conversion from PTS to DTS is safe here, since we don't
   // need to know currentTime precisely for GC. GC only needs to know which GOP
   // currentTime points to.
   DecodeTimestamp media_time_dts =
       DecodeTimestamp::FromPresentationTime(currentMediaTime);
 
   DCHECK(!id.empty());
   auto itr = source_state_map_.find(id);
   if (itr == source_state_map_.end()) {
     LOG(WARNING) << __func__ << " stream " << id << " not found";
     return false;
   }
-  return itr->second->EvictCodedFrames(media_time_dts, newDataSize);
+  return itr->second->EvictCodedFrames(media_time_dts, eviction_size);
 }
 
 bool ChunkDemuxer::AppendData(const std::string& id,
                               const uint8_t* data,
                               size_t length,
                               TimeDelta append_window_start,
                               TimeDelta append_window_end,
                               TimeDelta* timestamp_offset) {
   DVLOG(1) << "AppendData(" << id << ", " << length << ")";
 
@@ skipping 532 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (auto itr = source_state_map_.begin(); itr != source_state_map_.end();
        ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media