Add metric for tracking media playback utilization.

content/browser/media/media_internals.cc

 // Copyright (c) 2012 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/browser/media/media_internals.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 283 matching lines @@
     base::TimeDelta all_watch_time = media::kNoTimestamp;
     base::TimeDelta mse_watch_time = media::kNoTimestamp;
     base::TimeDelta eme_watch_time = media::kNoTimestamp;
     base::TimeDelta src_watch_time = media::kNoTimestamp;
     base::TimeDelta ac_watch_time = media::kNoTimestamp;
     base::TimeDelta battery_watch_time = media::kNoTimestamp;
   };
 
   struct PipelineInfo {
     bool has_pipeline = false;
+    bool has_ever_played = false;
+    bool has_reached_have_enough = false;
     media::PipelineStatus last_pipeline_status = media::PIPELINE_OK;
     bool has_audio = false;
     bool has_video = false;
     bool video_dds = false;
     bool video_decoder_changed = false;
     std::string audio_codec_name;
     std::string video_codec_name;
     std::string video_decoder;
     WatchTimeInfo watch_time_info;
   };
@@ skipping 76 matching lines @@
 
 MediaInternals::MediaInternalsUMAHandler::MediaInternalsUMAHandler() {
 }
 
 void MediaInternals::MediaInternalsUMAHandler::SavePlayerState(
     int render_process_id,
     const media::MediaLogEvent& event) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   PlayerInfoMap& player_info = renderer_info_[render_process_id];
   switch (event.type) {
+    case media::MediaLogEvent::PLAY: {
+      player_info[event.id].has_ever_played = true;
+      break;
+    }
     case media::MediaLogEvent::PIPELINE_STATE_CHANGED: {
       player_info[event.id].has_pipeline = true;
       break;
     }
     case media::MediaLogEvent::PIPELINE_ERROR: {
       int status;
       event.params.GetInteger("pipeline_error", &status);
       player_info[event.id].last_pipeline_status =
           static_cast<media::PipelineStatus>(status);
       break;
@@ skipping 20 matching lines @@
         event.params.GetString("video_decoder",
                                &player_info[event.id].video_decoder);
         if (!previous_video_decoder.empty() &&
             previous_video_decoder != player_info[event.id].video_decoder) {
           player_info[event.id].video_decoder_changed = true;
         }
       }
       if (event.params.HasKey("video_dds")) {
         event.params.GetBoolean("video_dds", &player_info[event.id].video_dds);
       }
+      if (event.params.HasKey("pipeline_buffering_state")) {
+        std::string buffering_state;
+        event.params.GetString("pipeline_buffering_state", &buffering_state);
+        if (buffering_state == "BUFFERING_HAVE_ENOUGH")
+          player_info[event.id].has_reached_have_enough = true;
+      }
       break;
     case media::MediaLogEvent::Type::WATCH_TIME_UPDATE: {
       DVLOG(2) << "Processing watch time update.";
       PipelineInfo& info = player_info[event.id];
       WatchTimeInfo& wti = info.watch_time_info;
       // Save audio only watch time information.
       MaybeSaveWatchTime(event, media::MediaLog::kWatchTimeAudioAll,
                          &wti.all_watch_time);
       MaybeSaveWatchTime(event, media::MediaLog::kWatchTimeAudioMse,
                          &wti.mse_watch_time);
@@ skipping 116 matching lines @@
     UMA_HISTOGRAM_ENUMERATION("Media.PipelineStatus.Unsupported",
                               player_info.last_pipeline_status,
                               media::PIPELINE_STATUS_MAX + 1);
   }
   // Report whether video decoder fallback happened, but only if a video decoder
   // was reported.
   if (!player_info.video_decoder.empty()) {
     UMA_HISTOGRAM_BOOLEAN("Media.VideoDecoderFallback",
                           player_info.video_decoder_changed);
   }
+
+  // Report whether this player ever saw a playback event. Used to measure the
+  // effectiveness of efforts to reduce loaded-but-never-used players.
+  if (player_info.has_reached_have_enough)
+    UMA_HISTOGRAM_BOOLEAN("Media.HasEverPlayed", player_info.has_ever_played);
 }
 
 void MediaInternals::MediaInternalsUMAHandler::OnProcessTerminated(
     int render_process_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   auto players_it = renderer_info_.find(render_process_id);
   if (players_it == renderer_info_.end())
     return;
   auto it = players_it->second.begin();
@@ skipping 258 matching lines @@
           audio_streams_cached_data_.GetDictionary(cache_key, &existing_dict));
       existing_dict->MergeDictionary(value);
     }
   }
 
   if (CanUpdate())
     SendUpdate(SerializeUpdate(function, value));
 }
 
 }  // namespace content