Experiment with more aggressive MSE GC on memory pressure

media/blink/webmediaplayer_impl.cc

Index: media/blink/webmediaplayer_impl.cc
diff --git a/media/blink/webmediaplayer_impl.cc b/media/blink/webmediaplayer_impl.cc
index 0ab7b54d2cfdf4ee3dc09c257d782eea66e0c312..75fb62ac30ed86c171721da8b7d8a67452c2f923 100644
--- a/media/blink/webmediaplayer_impl.cc
+++ b/media/blink/webmediaplayer_impl.cc
@@ -18,6 +18,7 @@
 #include "base/debug/alias.h"
 #include "base/debug/crash_logging.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
@@ -245,7 +246,9 @@ WebMediaPlayerImpl::WebMediaPlayerImpl(
       preroll_attempt_pending_(false),
       observer_(params.media_observer()),
       max_keyframe_distance_to_disable_background_video_(
-          params.max_keyframe_distance_to_disable_background_video()) {
+          params.max_keyframe_distance_to_disable_background_video()),
+      mse_force_gc_on_memory_pressure_(
+          params.mse_force_gc_on_memory_pressure()) {
   DCHECK(!adjust_allocated_memory_cb_.is_null());
   DCHECK(renderer_factory_);
   DCHECK(client_);
@@ -1168,6 +1171,23 @@ void WebMediaPlayerImpl::OnDemuxerOpened() {
       new WebMediaSourceImpl(chunk_demuxer_, media_log_));
 }
 
+void WebMediaPlayerImpl::OnMemoryPressure(
+    base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
+  DVLOG(2) << __func__ << " memory_pressure_level=" << memory_pressure_level;
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  DCHECK(base::FeatureList::IsEnabled(kReduceMSEBuffersOnMemoryPressure));
+  if (chunk_demuxer_) {

[DaleCurtis, 2017/01/26 23:07:37]

DCHECK(chunk_demuxer_) and just don't register the listener if it's not mse.

[servolk, 2017/01/27 00:52:13]

Done.

+    // base::Unretained is safe, since chunk_demuxer_ is actually owned by
+    // |this| via this->demuxer_.
+    media_task_runner_->PostTask(

[DaleCurtis, 2017/01/26 23:07:37]

I'm still not convinced why you need to provide the currenTime to ChunkDemuxer?
It knows the last read pts from the demuxer stream which should be close enough
to currentTime() to not matter.

[servolk, 2017/01/27 00:52:13]

The last read pts is not guaranteed to be close enough to currentTime(). Yes, it
happens to be fairly close in case of standard Chrome's standard RendererImpl
renderer. But for Chromecast we read data much further ahead of currentTime and
feed it into hardware pipeline, to ensure hw decoder pipeline is never stalled
(especially important on older 1st gen Chromecasts with slower single-core
CPUs).
Also even being pretty close is not good enough, currentTime might still be in
the previous GOP while the read position has advanced to the next GOP. MSE spec
says GC should preserve the GOP containing the currentTime(), not the last read
position (which is invisible from the app level anyway). 

+        FROM_HERE,
+        base::Bind(&ChunkDemuxer::OnMemoryPressure,
+                   base::Unretained(chunk_demuxer_),
+                   base::TimeDelta::FromSecondsD(currentTime()),
+                   memory_pressure_level, mse_force_gc_on_memory_pressure_));
+  }
+}
+
 void WebMediaPlayerImpl::OnError(PipelineStatus status) {
   DVLOG(1) << __func__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
@@ -1717,6 +1737,13 @@ void WebMediaPlayerImpl::StartPipeline() {
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnDemuxerOpened),
         encrypted_media_init_data_cb, media_log_);
     demuxer_.reset(chunk_demuxer_);
+
+    if (base::FeatureList::IsEnabled(kReduceMSEBuffersOnMemoryPressure)) {
+      // base::Unretained is safe because |this| owns memory_pressure_listener_.
+      memory_pressure_listener_ =
+          base::MakeUnique<base::MemoryPressureListener>(base::Bind(
+              &WebMediaPlayerImpl::OnMemoryPressure, base::Unretained(this)));
+    }
   }
 
   // TODO(sandersd): FileSystem objects may also be non-static, but due to our