Experiment with more aggressive MSE GC on memory pressure

media/blink/webmediaplayer_impl.cc

 // Copyright 2013 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/blink/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #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"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "cc/blink/web_layer_impl.h"
 #include "cc/layers/video_layer.h"
 #include "media/audio/null_audio_sink.h"
@@ skipping 1135 matching lines @@
     EnableVideoTrackIfNeeded();
   }
 }
 
 void WebMediaPlayerImpl::OnDemuxerOpened() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   client_->mediaSourceOpened(
       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_) {
+    // base::Unretained is safe, since chunk_demuxer_ is actually owned by
+    // |this| via this->demuxer_.
+    media_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&ChunkDemuxer::OnMemoryPressure,
+                              base::Unretained(chunk_demuxer_),
+                              base::TimeDelta::FromSecondsD(currentTime()),
+                              memory_pressure_level));
+  }
+}
+
 void WebMediaPlayerImpl::OnError(PipelineStatus status) {
   DVLOG(1) << __func__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(status, PIPELINE_OK);
 
   if (suppress_destruction_errors_)
     return;
 
   ReportPipelineError(load_type_, frame_->getSecurityOrigin(), status);
   media_log_->AddEvent(media_log_->CreatePipelineErrorEvent(status));
@@ skipping 533 matching lines @@
   // TODO(sandersd): FileSystem objects may also be non-static, but due to our
   // caching layer such situations are broken already. http://crbug.com/593159
   bool is_static = !chunk_demuxer_;
   bool is_streaming = IsStreaming();
   UMA_HISTOGRAM_BOOLEAN("Media.IsStreaming", is_streaming);
 
   // ... and we're ready to go!
   // TODO(sandersd): On Android, defer Start() if the tab is not visible.
   seeking_ = true;
   pipeline_controller_.Start(demuxer_.get(), this, is_streaming, is_static);
+
+  if (base::FeatureList::IsEnabled(kReduceMSEBuffersOnMemoryPressure)) {
+    // base::Unretained is safe because |this| owns memory_pressure_listener_.
+    memory_pressure_listener_ =

[chcunningham, 2017/01/25 03:47:15]

Do we want to make a new one every time the pipeline gets started? (e.g. if
someone calls load() more than once?). why not constructor?

Also, do you want to bother creating it when not media source?

[servolk, 2017/01/25 18:06:47]

I guess I wanted to avoid having the overhead of memory listener if a media
element is created, but not started. E.g. if there's a <video> element in the
page, but it's not autoplay.
But it's not a big deal, I guess. We can move it to where we are creating the
|chunk_demuxer_| for now.

[chcunningham, 2017/01/25 22:21:56]

Acknowledged.

+        base::MakeUnique<base::MemoryPressureListener>(base::Bind(
+            &WebMediaPlayerImpl::OnMemoryPressure, base::Unretained(this)));
+  }
 }
 
 void WebMediaPlayerImpl::SetNetworkState(WebMediaPlayer::NetworkState state) {
   DVLOG(1) << __func__ << "(" << state << ")";
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   network_state_ = state;
   // Always notify to ensure client has the latest value.
   client_->networkStateChanged();
 }
 
@@ skipping 446 matching lines @@
   pipeline_statistics_for_test_ = base::make_optional(stats);
 }
 
 PipelineStatistics WebMediaPlayerImpl::GetPipelineStatistics() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   return pipeline_statistics_for_test_.value_or(pipeline_.GetStatistics());
 }
 
 }  // namespace media