Start recording background video watch time.

media/base/media_log.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 "media/base/media_log.h"
 
 #include <utility>
 
 #include "base/atomic_sequence_num.h"
 #include "base/json/json_writer.h"
@@ skipping 23 matching lines @@
 // Audio only "watch time" metrics.
 const char MediaLog::kWatchTimeAudioAll[] = "Media.WatchTime.Audio.All";
 const char MediaLog::kWatchTimeAudioMse[] = "Media.WatchTime.Audio.MSE";
 const char MediaLog::kWatchTimeAudioEme[] = "Media.WatchTime.Audio.EME";
 const char MediaLog::kWatchTimeAudioSrc[] = "Media.WatchTime.Audio.SRC";
 const char MediaLog::kWatchTimeAudioBattery[] = "Media.WatchTime.Audio.Battery";
 const char MediaLog::kWatchTimeAudioAc[] = "Media.WatchTime.Audio.AC";
 const char MediaLog::kWatchTimeAudioEmbeddedExperience[] =
     "Media.WatchTime.Audio.EmbeddedExperience";
 
+// Audio+video background watch time metrics.
+const char MediaLog::kWatchTimeAudioVideoBackgroundAll[] =
+    "Media.WatchTime.AudioVideo.Background.All";
+const char MediaLog::kWatchTimeAudioVideoBackgroundMse[] =
+    "Media.WatchTime.AudioVideo.Background.MSE";
+const char MediaLog::kWatchTimeAudioVideoBackgroundEme[] =
+    "Media.WatchTime.AudioVideo.Background.EME";
+const char MediaLog::kWatchTimeAudioVideoBackgroundSrc[] =
+    "Media.WatchTime.AudioVideo.Background.SRC";
+const char MediaLog::kWatchTimeAudioVideoBackgroundBattery[] =
+    "Media.WatchTime.AudioVideo.Background.Battery";
+const char MediaLog::kWatchTimeAudioVideoBackgroundAc[] =
+    "Media.WatchTime.AudioVideo.Background.AC";
+const char MediaLog::kWatchTimeAudioVideoBackgroundEmbeddedExperience[] =
+    "Media.WatchTime.AudioVideo.Background.EmbeddedExperience";
+
 const char MediaLog::kWatchTimeFinalize[] = "FinalizeWatchTime";
 const char MediaLog::kWatchTimeFinalizePower[] = "FinalizePowerWatchTime";
 
+base::flat_set<base::StringPiece> MediaLog::GetWatchTimeKeys() {
+  return {kWatchTimeAudioAll,
+          kWatchTimeAudioMse,
+          kWatchTimeAudioEme,
+          kWatchTimeAudioSrc,
+          kWatchTimeAudioBattery,
+          kWatchTimeAudioAc,
+          kWatchTimeAudioEmbeddedExperience,
+          kWatchTimeAudioVideoAll,
+          kWatchTimeAudioVideoMse,
+          kWatchTimeAudioVideoEme,
+          kWatchTimeAudioVideoSrc,
+          kWatchTimeAudioVideoBattery,
+          kWatchTimeAudioVideoAc,
+          kWatchTimeAudioVideoEmbeddedExperience,
+          kWatchTimeAudioVideoBackgroundAll,
+          kWatchTimeAudioVideoBackgroundMse,
+          kWatchTimeAudioVideoBackgroundEme,
+          kWatchTimeAudioVideoBackgroundSrc,
+          kWatchTimeAudioVideoBackgroundBattery,
+          kWatchTimeAudioVideoBackgroundAc,
+          kWatchTimeAudioVideoBackgroundEmbeddedExperience};
+}
+
+base::flat_set<base::StringPiece> MediaLog::GetWatchTimePowerKeys() {
+  return {kWatchTimeAudioBattery,
+          kWatchTimeAudioAc,
+          kWatchTimeAudioVideoBattery,
+          kWatchTimeAudioVideoAc,
+          kWatchTimeAudioVideoBackgroundBattery,
+          kWatchTimeAudioVideoBackgroundAc};
+}
+
 std::string MediaLog::MediaLogLevelToString(MediaLogLevel level) {
   switch (level) {
     case MEDIALOG_ERROR:
       return "error";
     case MEDIALOG_INFO:
       return "info";
     case MEDIALOG_DEBUG:
       return "debug";
   }
   NOTREACHED();
@@ skipping 102 matching lines @@
 }
 
 std::string MediaLog::MediaEventToLogString(const MediaLogEvent& event) {
   // Special case for PIPELINE_ERROR, since that's by far the most useful
   // event for figuring out media pipeline failures, and just reporting
   // pipeline status as numeric code is not very helpful/user-friendly.
   int error_code = 0;
   if (event.type == MediaLogEvent::PIPELINE_ERROR &&
       event.params.GetInteger("pipeline_error", &error_code)) {
     PipelineStatus status = static_cast<PipelineStatus>(error_code);
-    return EventTypeToString(event.type) + " " +
-        media::MediaLog::PipelineStatusToString(status);
+    return EventTypeToString(event.type) + " " + PipelineStatusToString(status);
   }
   std::string params_json;
   base::JSONWriter::Write(event.params, &params_json);
   return EventTypeToString(event.type) + " " + params_json;
 }
 
 std::string MediaLog::BufferingStateToString(BufferingState state) {
   switch (state) {
     case BUFFERING_HAVE_NOTHING:
       return "BUFFERING_HAVE_NOTHING";
@@ skipping 152 matching lines @@
                      const scoped_refptr<MediaLog>& media_log)
     : level_(level), media_log_(media_log) {
   DCHECK(media_log_.get());
 }
 
 LogHelper::~LogHelper() {
   media_log_->AddLogEvent(level_, stream_.str());
 }
 
 }  //namespace media