Merge M56: "Add audio only watch time metrics."

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 317 matching lines @@
     double in_seconds;
     const bool result =
         event.params.GetDoubleWithoutPathExpansion(key, &in_seconds);
     DCHECK(result);
     *watch_time = base::TimeDelta::FromSecondsD(in_seconds);
 
     DVLOG(2) << "Saved watch time for " << key << " of " << *watch_time;
   }
 
   enum class FinalizeType { EVERYTHING, POWER_ONLY };
-  void FinalizeWatchTime(WatchTimeInfo* watch_time_info,
+  void FinalizeWatchTime(bool has_video,
+                         WatchTimeInfo* watch_time_info,
                          FinalizeType finalize_type) {
 // Use a macro instead of a function so we can use the histogram macro (which
 // checks that the uma name is a static value). We use a custom time range for
 // the histogram macro to capitalize on common expected watch times.
 #define MAYBE_RECORD_WATCH_TIME(uma_name, watch_time)                         \
   if (watch_time_info->watch_time != media::kNoTimestamp) {                   \
     UMA_HISTOGRAM_CUSTOM_TIMES(                                               \
         media::MediaLog::uma_name, watch_time_info->watch_time,               \
         base::TimeDelta::FromSeconds(7), base::TimeDelta::FromHours(10), 50); \
     watch_time_info->watch_time = media::kNoTimestamp;                        \
   }
 
-    if (finalize_type == FinalizeType::EVERYTHING) {
-      MAYBE_RECORD_WATCH_TIME(kWatchTimeAudioVideoAll, all_watch_time);
-      MAYBE_RECORD_WATCH_TIME(kWatchTimeAudioVideoMse, mse_watch_time);
-      MAYBE_RECORD_WATCH_TIME(kWatchTimeAudioVideoEme, eme_watch_time);
-      MAYBE_RECORD_WATCH_TIME(kWatchTimeAudioVideoSrc, src_watch_time);
+    if (has_video) {
+      if (finalize_type == FinalizeType::EVERYTHING) {
+        MAYBE_RECORD_WATCH_TIME(kWatchTimeAudioVideoAll, all_watch_time);
+        MAYBE_RECORD_WATCH_TIME(kWatchTimeAudioVideoMse, mse_watch_time);
+        MAYBE_RECORD_WATCH_TIME(kWatchTimeAudioVideoEme, eme_watch_time);
+        MAYBE_RECORD_WATCH_TIME(kWatchTimeAudioVideoSrc, src_watch_time);
+      } else {
+        DCHECK_EQ(finalize_type, FinalizeType::POWER_ONLY);
+      }
+      MAYBE_RECORD_WATCH_TIME(kWatchTimeAudioVideoBattery, battery_watch_time);
+      MAYBE_RECORD_WATCH_TIME(kWatchTimeAudioVideoAc, ac_watch_time);
     } else {
-      DCHECK_EQ(finalize_type, FinalizeType::POWER_ONLY);
+      if (finalize_type == FinalizeType::EVERYTHING) {
+        MAYBE_RECORD_WATCH_TIME(kWatchTimeAudioAll, all_watch_time);
+        MAYBE_RECORD_WATCH_TIME(kWatchTimeAudioMse, mse_watch_time);
+        MAYBE_RECORD_WATCH_TIME(kWatchTimeAudioEme, eme_watch_time);
+        MAYBE_RECORD_WATCH_TIME(kWatchTimeAudioSrc, src_watch_time);
+      } else {
+        DCHECK_EQ(finalize_type, FinalizeType::POWER_ONLY);
+      }
+      MAYBE_RECORD_WATCH_TIME(kWatchTimeAudioBattery, battery_watch_time);
+      MAYBE_RECORD_WATCH_TIME(kWatchTimeAudioAc, ac_watch_time);
     }
-    MAYBE_RECORD_WATCH_TIME(kWatchTimeAudioVideoBattery, battery_watch_time);
-    MAYBE_RECORD_WATCH_TIME(kWatchTimeAudioVideoAc, ac_watch_time);
 #undef MAYBE_RECORD_WATCH_TIME
   }
 
   // Key is player id.
   typedef std::map<int, PipelineInfo> PlayerInfoMap;
 
   // Key is renderer id.
   typedef std::map<int, PlayerInfoMap> RendererPlayerMap;
 
   // Stores player information per renderer.
@@ skipping 47 matching lines @@
             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);
       }
       break;
     case media::MediaLogEvent::Type::WATCH_TIME_UPDATE: {
       DVLOG(2) << "Processing watch time update.";
-      WatchTimeInfo& wti = player_info[event.id].watch_time_info;
+      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);
+      MaybeSaveWatchTime(event, media::MediaLog::kWatchTimeAudioEme,
+                         &wti.eme_watch_time);
+      MaybeSaveWatchTime(event, media::MediaLog::kWatchTimeAudioSrc,
+                         &wti.src_watch_time);
+      MaybeSaveWatchTime(event, media::MediaLog::kWatchTimeAudioBattery,
+                         &wti.battery_watch_time);
+      MaybeSaveWatchTime(event, media::MediaLog::kWatchTimeAudioAc,
+                         &wti.ac_watch_time);
+
+      // Save audio+video watch time information.
       MaybeSaveWatchTime(event, media::MediaLog::kWatchTimeAudioVideoAll,
                          &wti.all_watch_time);
       MaybeSaveWatchTime(event, media::MediaLog::kWatchTimeAudioVideoMse,
                          &wti.mse_watch_time);
       MaybeSaveWatchTime(event, media::MediaLog::kWatchTimeAudioVideoEme,
                          &wti.eme_watch_time);
       MaybeSaveWatchTime(event, media::MediaLog::kWatchTimeAudioVideoSrc,
                          &wti.src_watch_time);
       MaybeSaveWatchTime(event, media::MediaLog::kWatchTimeAudioVideoBattery,
                          &wti.battery_watch_time);
       MaybeSaveWatchTime(event, media::MediaLog::kWatchTimeAudioVideoAc,
                          &wti.ac_watch_time);
 
       if (event.params.HasKey(media::MediaLog::kWatchTimeFinalize)) {
         bool should_finalize;
         DCHECK(event.params.GetBoolean(media::MediaLog::kWatchTimeFinalize,
                                        &should_finalize) &&
                should_finalize);
-        FinalizeWatchTime(&wti, FinalizeType::EVERYTHING);
+        FinalizeWatchTime(info.has_video, &wti, FinalizeType::EVERYTHING);
       } else if (event.params.HasKey(
                      media::MediaLog::kWatchTimeFinalizePower)) {
         bool should_finalize;
         DCHECK(event.params.GetBoolean(media::MediaLog::kWatchTimeFinalizePower,
                                        &should_finalize) &&
                should_finalize);
-        FinalizeWatchTime(&wti, FinalizeType::POWER_ONLY);
+        FinalizeWatchTime(info.has_video, &wti, FinalizeType::POWER_ONLY);
       }
       break;
     }
     case media::MediaLogEvent::Type::WEBMEDIAPLAYER_DESTROYED: {
       // Upon player destruction report UMA data; if the player is not torn down
       // before process exit, it will be logged during OnProcessTerminated().
       auto it = player_info.find(event.id);
       if (it == player_info.end())
         break;
 
@@ skipping 82 matching lines @@
 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();
   while (it != players_it->second.end()) {
     ReportUMAForPipelineStatus(it->second);
-    FinalizeWatchTime(&(it->second.watch_time_info), FinalizeType::EVERYTHING);
+    FinalizeWatchTime(it->second.has_video, &(it->second.watch_time_info),
+                      FinalizeType::EVERYTHING);
     players_it->second.erase(it++);
   }
   renderer_info_.erase(players_it);
 }
 
 MediaInternals* MediaInternals::GetInstance() {
   return g_media_internals.Pointer();
 }
 
 MediaInternals::MediaInternals()
@@ skipping 243 matching lines @@
           audio_streams_cached_data_.GetDictionary(cache_key, &existing_dict));
       existing_dict->MergeDictionary(value);
     }
   }
 
   if (CanUpdate())
     SendUpdate(SerializeUpdate(function, value));
 }
 
 }  // namespace content