Added metrics for background video playback.

content/renderer/media/renderer_webmediaplayer_delegate.cc

Index: content/renderer/media/renderer_webmediaplayer_delegate.cc
diff --git a/content/renderer/media/renderer_webmediaplayer_delegate.cc b/content/renderer/media/renderer_webmediaplayer_delegate.cc
index 24dc39d79529c7e630986317a29d188373d725f7..1d3b8a88171391c54f2bbbec28b7a7f2135ef14a 100644
--- a/content/renderer/media/renderer_webmediaplayer_delegate.cc
+++ b/content/renderer/media/renderer_webmediaplayer_delegate.cc
@@ -7,10 +7,22 @@
 #include <stdint.h>
 
 #include "base/auto_reset.h"
+#include "base/metrics/histogram_macros.h"
+#include "base/metrics/user_metrics_action.h"
+#include "base/power_monitor/power_monitor.h"
 #include "content/common/media/media_player_delegate_messages.h"
 #include "content/public/renderer/render_frame.h"
+#include "content/public/renderer/render_thread.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayer.h"
 
+namespace {
+
+void RecordAction(const base::UserMetricsAction& action) {
+  content::RenderThread::Get()->RecordAction(action);

[mlamouri (slow - plz ping), 2016/08/08 13:19:30]

You could also make it take a std::string and do the base::UserMetricsAction
casting in there.

[whywhat, 2016/08/11 21:51:04]

Done. I don't think extract_actions.py would extract all the actions correctly
though in this case.

+}
+
+}  // namespace
+
 namespace media {
 
 RendererWebMediaPlayerDelegate::RendererWebMediaPlayerDelegate(
@@ -20,9 +32,25 @@ RendererWebMediaPlayerDelegate::RendererWebMediaPlayerDelegate(
       tick_clock_(default_tick_clock_.get()) {
   idle_cleanup_interval_ = base::TimeDelta::FromSeconds(5);
   idle_timeout_ = base::TimeDelta::FromSeconds(15);
+  base::PowerMonitor::Get()->AddObserver(this);
 }
 
-RendererWebMediaPlayerDelegate::~RendererWebMediaPlayerDelegate() {}
+RendererWebMediaPlayerDelegate::~RendererWebMediaPlayerDelegate() {
+  SetIsPlayingBackgroundVideo(false);
+  base::PowerMonitor::Get()->RemoveObserver(this);
+}
+
+void RendererWebMediaPlayerDelegate::OnSuspend() {
+  if (is_playing_background_video_)
+    power_suspended_time_ = base::TimeTicks::Now();

[mlamouri (slow - plz ping), 2016/08/08 13:19:30]

I'm a bit confused about this change. If I understand correctly, we want to
substract this time from the playback time. However, Suspend state seems to be
related to: ApplicationState.HAS_PAUSED_ACTIVITIES (see
https://cs.chromium.org/chromium/src/base/android/java/src/org/chromium/base/...)

Which seems to be linked with the activity being paused:
https://cs.chromium.org/chromium/src/base/android/java/src/org/chromium/base/...

My understanding is that the Activity will receive onPause() when it is
partially visible and onStop() when fully hidden (see
https://developer.android.com/training/basics/activity-lifecycle/pausing.html).
It seems that all these events are noise given that we want to record video
playback in the background.

Dale, does suspend behave differently on other platforms? Given that we are
aiming Android, it sounds that we shouldn't actually use PowerMonitor here
unless I'm missing something :(

[DaleCurtis, 2016/08/08 18:26:45]

Yes, suspend behaves differently on other platforms. I also think this wouldn't
work even on those other platforms since you don't know exactly when
base::TimeTicks::Now() will start returning the correct time. I don't think it's
guaranteed to do so between the bounds of OnSuspend / OnResume -- Instead of
subtracting the time you probably want to drop the measurement completely.

OnSuspend/OnResume on android are not sent with any real effective meaning for
media. The OnSuspend happens ~30 seconds after going into the background, but
doesn't actually mean the process is suspended like on other platforms.

If you limit this to Android only you can avoid having to worry about this.

[whywhat, 2016/08/11 21:51:04]

#ifdef'ed with OS_ANDROID, if that's what you meant.
Removed the PowerObserver logic.

+}
+
+void RendererWebMediaPlayerDelegate::OnResume() {
+  if (is_playing_background_video_) {

[mlamouri (slow - plz ping), 2016/08/08 13:19:30]

nit: here and above, you could do an early return. Feel free to ignore.

[whywhat, 2016/08/11 21:51:04]

N/A

+    background_video_playing_start_time_ +=
+        base::TimeTicks::Now() - power_suspended_time_;
+  }
+}
 
 int RendererWebMediaPlayerDelegate::AddObserver(Observer* observer) {
   return id_map_.Add(observer);
@@ -80,12 +108,16 @@ bool RendererWebMediaPlayerDelegate::IsPlayingBackgroundVideo() {
 void RendererWebMediaPlayerDelegate::WasHidden() {
   for (IDMap<Observer>::iterator it(&id_map_); !it.IsAtEnd(); it.Advance())
     it.GetCurrentValue()->OnHidden();
+
+  RecordAction(base::UserMetricsAction("Media.Hidden"));
 }
 
 void RendererWebMediaPlayerDelegate::WasShown() {
-  is_playing_background_video_ = false;
+  SetIsPlayingBackgroundVideo(false);
   for (IDMap<Observer>::iterator it(&id_map_); !it.IsAtEnd(); it.Advance())
     it.GetCurrentValue()->OnShown();
+
+  RecordAction(base::UserMetricsAction("Media.Shown"));
 }
 
 bool RendererWebMediaPlayerDelegate::OnMessageReceived(
@@ -115,18 +147,22 @@ void RendererWebMediaPlayerDelegate::OnMediaDelegatePause(int delegate_id) {
   Observer* observer = id_map_.Lookup(delegate_id);
   if (observer) {
     if (playing_videos_.find(delegate_id) != playing_videos_.end())
-      is_playing_background_video_ = false;
+      SetIsPlayingBackgroundVideo(false);
     observer->OnPause();
   }
+
+  RecordAction(base::UserMetricsAction("Media.RemoteControls.Pause"));
 }
 
 void RendererWebMediaPlayerDelegate::OnMediaDelegatePlay(int delegate_id) {
   Observer* observer = id_map_.Lookup(delegate_id);
   if (observer) {
     if (playing_videos_.find(delegate_id) != playing_videos_.end())
-      is_playing_background_video_ = IsHidden();
+      SetIsPlayingBackgroundVideo(IsHidden());
     observer->OnPlay();
   }
+
+  RecordAction(base::UserMetricsAction("Media.RemoteControls.Play"));
 }
 
 void RendererWebMediaPlayerDelegate::OnMediaDelegateSuspendAllMediaPlayers() {
@@ -193,6 +229,22 @@ void RendererWebMediaPlayerDelegate::CleanupIdleDelegates() {
     idle_cleanup_timer_.Stop();
 }
 
+void RendererWebMediaPlayerDelegate::SetIsPlayingBackgroundVideo(
+    bool is_playing) {
+  if (is_playing_background_video_ == is_playing) return;
+
+  if (is_playing_background_video_) {
+    UMA_HISTOGRAM_LONG_TIMES(
+        "Media.Session.BackgroundTime",
+        base::TimeTicks::Now() - background_video_playing_start_time_);
+    RecordAction(base::UserMetricsAction("Media.Session.BackgroundSuspend"));
+  } else {
+    background_video_playing_start_time_ = base::TimeTicks::Now();
+    RecordAction(base::UserMetricsAction("Media.Session.BackgroundResume"));
+  }
+  is_playing_background_video_ = is_playing;
+}
+
 void RendererWebMediaPlayerDelegate::OnDestruct() {
   delete this;
 }