Report WMPI components memory usage to UMA

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 1042 matching lines @@
 #endif
 
   // If we're not in an aggressive buffering state, tell the data source we have
   // enough data so that it may release the connection.
   if (buffering_strategy_ !=
       MultibufferDataSource::BUFFERING_STRATEGY_AGGRESSIVE) {
     if (data_source_)
       data_source_->OnBufferingHaveEnough(true);
   }
 
-  ReportMemoryUsage();
+  ReportMemoryUsage(OptionalMemoryPressureLevel());
 
   if (pending_suspend_resume_cycle_) {
     pending_suspend_resume_cycle_ = false;
     UpdatePlayState();
   }
 }
 
 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) {
   DVLOG(1) << __func__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(status, PIPELINE_OK);
 
   if (suppress_destruction_errors_)
     return;
 
@@ skipping 87 matching lines @@
     // to release unused network connections.
     if (data_source_)
       data_source_->OnBufferingHaveEnough(false);
 
     // Blink expects a timeChanged() in response to a seek().
     if (should_notify_time_changed_)
       client_->timeChanged();
 
     // 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.
     if (underflow_timer_ && data_source_) {
       UMA_HISTOGRAM_TIMES("Media.UnderflowDuration",
                           underflow_timer_->Elapsed());
       underflow_timer_.reset();
     }
   } else {
     // Buffering has underflowed.
@@ skipping 544 matching lines @@
 }
 
 void WebMediaPlayerImpl::SetMemoryReportingState(
     bool is_memory_reporting_enabled) {
   if (memory_usage_reporting_timer_.IsRunning() ==
       is_memory_reporting_enabled) {
     return;
   }
 
   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());
   }
 }
 
 void WebMediaPlayerImpl::SetSuspendState(bool is_suspended) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   // Do not change the state after an error has occurred.
   // TODO(sandersd): Update PipelineController to remove the need for this.
   if (IsNetworkStateError(network_state_))
     return;
@@ skipping 120 matching lines @@
   }
 
   // It's not critical if some cases where memory usage can change are missed,
   // since media memory changes are usually gradual.
   result.is_memory_reporting_enabled =
       can_play && !result.is_suspended && !paused_;
 
   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
   // thread.  Before that, however, ~WebMediaPlayerImpl() posts a task to the
   // media thread and waits for it to finish.  Hence, the GetMemoryUsage() task
   // posted here must finish earlier.
 
   if (demuxer_) {
     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 MemoryPressureLevelToString(
+    base::MemoryPressureListener::MemoryPressureLevel 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";
+  }
+  NOTREACHED();
+  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 = "";
+  if (memory_pressure_level) {
+    memory_pressure_log = " (Memory pressure: " +
+                          MemoryPressureLevelToString(*memory_pressure_level) +
+                          ")";
+  }
 
   // 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);
+
+  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);

[DaleCurtis, 2016/12/14 19:33:23]

Typo?

[servolk, 2016/12/14 19:47:11]

Oops, yes, fixed.

+  UMA_HISTOGRAM_MEMORY_KB("Media.WebMediaPlayerImpl.Memory.Demuxer",
+                          demuxer_memory_usage / 1024);
 }
 
 void WebMediaPlayerImpl::ScheduleIdlePauseTimer() {
   // Only schedule the pause timer if we're playing and are suspended.
   if (paused_ || !pipeline_controller_.IsSuspended())
     return;
 
 #if defined(OS_ANDROID)
   // Remote players will be suspended and locally paused.
   if (isRemote())
@@ skipping 18 matching lines @@
     watch_time_reporter_->OnShown();
 }
 
 bool WebMediaPlayerImpl::IsHidden() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   return delegate_ && delegate_->IsHidden();
 }
 
 }  // namespace media