Added metrics for background video playback.

content/renderer/media/renderer_webmediaplayer_delegate.cc

 // Copyright 2015 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 "content/renderer/media/renderer_webmediaplayer_delegate.h"
 
 #include <stdint.h>
 
 #include "base/auto_reset.h"
+#include "base/metrics/histogram_macros.h"
+#include "base/metrics/user_metrics_action.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);
+}
+
+}  // namespace
+
 namespace media {
 
 RendererWebMediaPlayerDelegate::RendererWebMediaPlayerDelegate(
     content::RenderFrame* render_frame)
     : RenderFrameObserver(render_frame),
       default_tick_clock_(new base::DefaultTickClock()),
       tick_clock_(default_tick_clock_.get()) {
   idle_cleanup_interval_ = base::TimeDelta::FromSeconds(5);
   idle_timeout_ = base::TimeDelta::FromSeconds(15);
 }
@@ skipping 49 matching lines @@
   return render_frame()->IsHidden();
 }
 
 bool RendererWebMediaPlayerDelegate::IsPlayingBackgroundVideo() {
   return is_playing_background_video_;
 }
 
 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(
     const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RendererWebMediaPlayerDelegate, msg)
     IPC_MESSAGE_HANDLER(MediaPlayerDelegateMsg_Pause, OnMediaDelegatePause)
     IPC_MESSAGE_HANDLER(MediaPlayerDelegateMsg_Play, OnMediaDelegatePlay)
     IPC_MESSAGE_HANDLER(MediaPlayerDelegateMsg_SuspendAllMediaPlayers,
                         OnMediaDelegateSuspendAllMediaPlayers)
     IPC_MESSAGE_HANDLER(MediaPlayerDelegateMsg_UpdateVolumeMultiplier,
                         OnMediaDelegateVolumeMultiplierUpdate)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void RendererWebMediaPlayerDelegate::SetIdleCleanupParamsForTesting(
     base::TimeDelta idle_timeout,
     base::TickClock* tick_clock) {
   idle_cleanup_interval_ = base::TimeDelta();
   idle_timeout_ = idle_timeout;
   tick_clock_ = tick_clock;
 }
 
 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() {
   for (IDMap<Observer>::iterator it(&id_map_); !it.IsAtEnd(); it.Advance())
     it.GetCurrentValue()->OnSuspendRequested(true);
 }
 
 void RendererWebMediaPlayerDelegate::OnMediaDelegateVolumeMultiplierUpdate(
     int delegate_id,
     double multiplier) {
@@ skipping 46 matching lines @@
       it = idle_delegate_map_.erase(it);
     else
       ++it;
   }
 
   // Shutdown the timer if no delegates are left.
   if (idle_delegate_map_.empty())
     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_);

[DaleCurtis, 2016/08/05 17:39:22]

Keep in mind that once you start talking about elapsed real time you are
including things like system suspend, etc. So some massive numbers can show up
in your data set unexpectedly. If you don't want this the typical thing to do is
use a PowerObserver to cancel during suspend.

[whywhat, 2016/08/05 20:49:24]

Good point. I assume nothing can happen between OnSuspend and OnResume? I've
added some logic to subtract time spend in power suspended mode from the
measurements.

+    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;
 }
 
 }  // namespace media