Report WMPI components memory usage to UMA

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 a105327d0635b16c4d2fdc937a2cb7a89c32fa91..e6fb83daab9622fd4650060ac6f5c9c203cee698 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"
@@ -1080,7 +1081,7 @@ void WebMediaPlayerImpl::OnPipelineSuspended() {
       data_source_->OnBufferingHaveEnough(true);
   }
 
-  ReportMemoryUsage();
+  ReportMemoryUsage(OptionalMemoryPressureLevel());
 
   if (pending_suspend_resume_cycle_) {
     pending_suspend_resume_cycle_ = false;
@@ -1092,6 +1093,16 @@ void WebMediaPlayerImpl::OnDemuxerOpened() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   client_->mediaSourceOpened(
       new WebMediaSourceImpl(chunk_demuxer_, media_log_));
+  // base::Unretained is safe because |this| outlives memory_pressure_listener_.
+  memory_pressure_listener_ =
+      base::MakeUnique<base::MemoryPressureListener>(base::Bind(
+          &WebMediaPlayerImpl::OnMemoryPressure, base::Unretained(this)));
+}
+
+void WebMediaPlayerImpl::OnMemoryPressure(
+    base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  ReportMemoryUsage(memory_pressure_level);
 }
 
 void WebMediaPlayerImpl::OnError(PipelineStatus status) {
@@ -1199,7 +1210,7 @@ void WebMediaPlayerImpl::OnBufferingStateChange(BufferingState state) {
 
     // Once we have enough, start reporting the total memory usage. We'll also
     // report once playback starts.
-    ReportMemoryUsage();
+    ReportMemoryUsage(OptionalMemoryPressureLevel());
 
     // Report the amount of time it took to leave the underflow state. Don't
     // bother to report this for MSE playbacks since it's out of our control.
@@ -1764,12 +1775,15 @@ void WebMediaPlayerImpl::SetMemoryReportingState(
   }
 
   if (is_memory_reporting_enabled) {
-    memory_usage_reporting_timer_.Start(FROM_HERE,
-                                        base::TimeDelta::FromSeconds(2), this,
-                                        &WebMediaPlayerImpl::ReportMemoryUsage);
+    // base::Unretained is safe because |this| outlives
+    // memory_usage_reporting_timer_.
+    memory_usage_reporting_timer_.Start(
+        FROM_HERE, base::TimeDelta::FromSeconds(2),
+        base::Bind(&WebMediaPlayerImpl::ReportMemoryUsage,
+                   base::Unretained(this), OptionalMemoryPressureLevel()));
   } else {
     memory_usage_reporting_timer_.Stop();
-    ReportMemoryUsage();
+    ReportMemoryUsage(OptionalMemoryPressureLevel());
   }
 }
 
@@ -1910,7 +1924,8 @@ WebMediaPlayerImpl::UpdatePlayState_ComputePlayState(bool is_remote,
   return result;
 }
 
-void WebMediaPlayerImpl::ReportMemoryUsage() {
+void WebMediaPlayerImpl::ReportMemoryUsage(
+    OptionalMemoryPressureLevel memory_pressure_level) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   // About base::Unretained() usage below: We destroy |demuxer_| on the main
@@ -1922,32 +1937,70 @@ void WebMediaPlayerImpl::ReportMemoryUsage() {
     base::PostTaskAndReplyWithResult(
         media_task_runner_.get(), FROM_HERE,
         base::Bind(&Demuxer::GetMemoryUsage, base::Unretained(demuxer_.get())),
-        base::Bind(&WebMediaPlayerImpl::FinishMemoryUsageReport, AsWeakPtr()));
+        base::Bind(&WebMediaPlayerImpl::FinishMemoryUsageReport, AsWeakPtr(),
+                   memory_pressure_level));
   } else {
-    FinishMemoryUsageReport(0);
+    FinishMemoryUsageReport(memory_pressure_level, 0);
   }
 }
 
-void WebMediaPlayerImpl::FinishMemoryUsageReport(int64_t demuxer_memory_usage) {
+std::string MaybeMemPressureToLogString(

[watk, 2016/12/14 00:34:05]

If you want this to be reusable (which I personally wouldn't worry about at the
moment), you'd be better off taking a MemoryPressureLevel, not an optional.
MemoryPressureLevelToString()? "Maybe" is out of date. "Log" feels redundant.

[servolk, 2016/12/14 02:34:34]

Done.

+    const base::Optional<base::MemoryPressureListener::MemoryPressureLevel>&
+        memory_pressure_level) {
+  if (memory_pressure_level) {
+    switch (*memory_pressure_level) {
+      case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE:
+        return "none";
+      case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE:
+        return "moderate";
+      case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL:
+        return "critical";
+    }
+  }
+  return "";
+}
+
+void WebMediaPlayerImpl::FinishMemoryUsageReport(
+    OptionalMemoryPressureLevel memory_pressure_level,
+    int64_t demuxer_memory_usage) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   const PipelineStatistics stats = pipeline_.GetStatistics();
+  const int64_t data_source_memory_usage =
+      (data_source_ ? data_source_->GetMemoryUsage() : 0);
   const int64_t current_memory_usage =
       stats.audio_memory_usage + stats.video_memory_usage +
-      (data_source_ ? data_source_->GetMemoryUsage() : 0) +
-      demuxer_memory_usage;
+      data_source_memory_usage + demuxer_memory_usage;
+
+  std::string memory_pressure_log =
+      MaybeMemPressureToLogString(memory_pressure_level);
+  if (memory_pressure_log != "")
+    memory_pressure_log = " (Memory pressure: " + memory_pressure_log + ")";
 
   // Note, this isn't entirely accurate, there may be VideoFrames held by the
   // compositor or other resources that we're unaware of.
-
-  DVLOG(2) << "Memory Usage -- Audio: " << stats.audio_memory_usage
-           << ", Video: " << stats.video_memory_usage << ", DataSource: "
-           << (data_source_ ? data_source_->GetMemoryUsage() : 0)
+  DVLOG(2) << "Memory Usage " << memory_pressure_log
+           << " -- Audio: " << stats.audio_memory_usage
+           << ", Video: " << stats.video_memory_usage
+           << ", DataSource: " << data_source_memory_usage
            << ", Demuxer: " << demuxer_memory_usage;
 
   const int64_t delta = current_memory_usage - last_reported_memory_usage_;
   last_reported_memory_usage_ = current_memory_usage;
   adjust_allocated_memory_cb_.Run(delta);
+
+  if (memory_pressure_level &&
+      *memory_pressure_level >=

[watk, 2016/12/14 00:34:05]

Doesn't really matter, but you don't need the deref
(https://cs.chromium.org/chromium/src/base/optional.h?q=base::optional&sq=pack...)

[servolk, 2016/12/14 02:34:33]

Done.

+          base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE) {
+    UMA_HISTOGRAM_MEMORY_KB("Media.WebMediaPlayerImpl.Memory.Audio",
+                            stats.audio_memory_usage / 1024);
+    UMA_HISTOGRAM_MEMORY_KB("Media.WebMediaPlayerImpl.Memory.Video",
+                            stats.video_memory_usage / 1024);
+    UMA_HISTOGRAM_MEMORY_KB("Media.WebMediaPlayerImpl.Memory.DataSource",
+                            stats.video_memory_usage / 1024);
+    UMA_HISTOGRAM_MEMORY_KB("Media.WebMediaPlayerImpl.Memory.Demuxer",
+                            demuxer_memory_usage / 1024);
+  }
 }
 
 void WebMediaPlayerImpl::ScheduleIdlePauseTimer() {