Start recording background video watch time.

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>
 
+#include "base/containers/flat_map.h"
+#include "base/containers/flat_set.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
@@ skipping 261 matching lines @@
   // Called when a render process is terminated. Reports the pipeline status to
   // UMA for every player associated with the renderer process and then deletes
   // the player state.
   void OnProcessTerminated(int render_process_id);
 
   // Helper function to save the event payload to RendererPlayerMap.
   void SavePlayerState(int render_process_id,
                        const media::MediaLogEvent& event);
 
  private:
-  struct WatchTimeInfo {
-    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;
-    base::TimeDelta embedded_experience_watch_time = media::kNoTimestamp;
-  };
-
+  using WatchTimeInfo = base::flat_map<base::StringPiece, base::TimeDelta>;
   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;
   };
 
   // Helper function to report PipelineStatus associated with a player to UMA.
   void ReportUMAForPipelineStatus(const PipelineInfo& player_info);
 
   // Helper to generate PipelineStatus UMA name for AudioVideo streams.
   std::string GetUMANameForAVStream(const PipelineInfo& player_info);
 
-  // Saves the watch time info from |event| under |key| at |watch_time| if |key|
-  // is present in |event.params|.
-  void MaybeSaveWatchTime(const media::MediaLogEvent& event,
-                          const char* key,
-                          base::TimeDelta* watch_time) {
-    if (!event.params.HasKey(key))
-      return;
-
-    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;
+  void RecordWatchTime(const base::StringPiece& key, base::TimeDelta value) {
+    base::Histogram::FactoryTimeGet(
+        key.as_string(), base::TimeDelta::FromSeconds(7),
+        base::TimeDelta::FromHours(10), 50,
+        base::HistogramBase::kUmaTargetedHistogramFlag)
+        ->AddTime(value);
   }
 
   enum class FinalizeType { EVERYTHING, POWER_ONLY };
   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) {
+      for (auto& kv : *watch_time_info)
+        RecordWatchTime(kv.first, kv.second);
+      watch_time_info->clear();
+      return;
+    }
 
-    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);
-        MAYBE_RECORD_WATCH_TIME(kWatchTimeAudioVideoEmbeddedExperience,
-                                embedded_experience_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 {
-      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);
-        MAYBE_RECORD_WATCH_TIME(kWatchTimeAudioEmbeddedExperience,
-                                embedded_experience_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);
+    DCHECK_EQ(finalize_type, FinalizeType::POWER_ONLY);
+    for (auto power_key : watch_time_power_keys_) {
+      auto it = watch_time_info->find(power_key);
+      if (it == watch_time_info->end())
+        continue;
+      RecordWatchTime(it->first, it->second);
+      watch_time_info->erase(it);
     }
-#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.
   RendererPlayerMap renderer_info_;
 
+  const base::flat_set<base::StringPiece> watch_time_keys_;
+  const base::flat_set<base::StringPiece> watch_time_power_keys_;
+
   DISALLOW_COPY_AND_ASSIGN(MediaInternalsUMAHandler);
 };
 
-MediaInternals::MediaInternalsUMAHandler::MediaInternalsUMAHandler() {
-}
+MediaInternals::MediaInternalsUMAHandler::MediaInternalsUMAHandler()
+    : watch_time_keys_(media::MediaLog::GetWatchTimeKeys()),
+      watch_time_power_keys_(media::MediaLog::GetWatchTimePowerKeys()) {}
 
 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;
@@ skipping 41 matching lines @@
       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);
-      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);
-      MaybeSaveWatchTime(event,
-                         media::MediaLog::kWatchTimeAudioEmbeddedExperience,
-                         &wti.embedded_experience_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);
-      MaybeSaveWatchTime(
-          event, media::MediaLog::kWatchTimeAudioVideoEmbeddedExperience,
-          &wti.embedded_experience_watch_time);
+      for (base::DictionaryValue::Iterator it(event.params); !it.IsAtEnd();
+           it.Advance()) {
+        // Don't log random histogram keys from the untrusted renderer, instead
+        // ensure they are from our list of known keys. Use |key_name| from the
+        // key map, since otherwise we'll end up storing a StringPiece which
+        // points into the soon-to-be-destructed DictionaryValue.
+        auto key_name = watch_time_keys_.find(it.key());
+        if (key_name == watch_time_keys_.end())
+          continue;
+        info.watch_time_info[*key_name] =
+            base::TimeDelta::FromSecondsD(it.value().GetDouble());
+      }
 
       if (event.params.HasKey(media::MediaLog::kWatchTimeFinalize)) {
         bool should_finalize;
         DCHECK(event.params.GetBoolean(media::MediaLog::kWatchTimeFinalize,
                                        &should_finalize) &&
                should_finalize);
-        FinalizeWatchTime(info.has_video, &wti, FinalizeType::EVERYTHING);
+        FinalizeWatchTime(info.has_video, &info.watch_time_info,
+                          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(info.has_video, &wti, FinalizeType::POWER_ONLY);
+        FinalizeWatchTime(info.has_video, &info.watch_time_info,
+                          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;
 
       ReportUMAForPipelineStatus(it->second);
+      FinalizeWatchTime(it->second.has_video, &(it->second.watch_time_info),
+                        FinalizeType::EVERYTHING);
       player_info.erase(it);
     }
     default:
       break;
   }
   return;
 }
 
 std::string MediaInternals::MediaInternalsUMAHandler::GetUMANameForAVStream(
     const PipelineInfo& player_info) {
@@ skipping 273 matching lines @@
 
 void MediaInternals::SetWebContentsTitleForAudioLogEntry(
     int component_id,
     int render_process_id,
     int render_frame_id,
     media::AudioLog* audio_log) {
   static_cast<AudioLogImpl*>(audio_log)
       ->SendWebContentsTitle(component_id, render_process_id, render_frame_id);
 }
 
+void MediaInternals::OnProcessTerminatedForTesting(int process_id) {
+  uma_handler_->OnProcessTerminated(process_id);
+}
+
 void MediaInternals::SendUpdate(const base::string16& update) {
   // SendUpdate() may be called from any thread, but must run on the UI thread.
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
         &MediaInternals::SendUpdate, base::Unretained(this), update));
     return;
   }
 
   for (size_t i = 0; i < update_callbacks_.size(); i++)
     update_callbacks_[i].Run(update);
@@ skipping 49 matching lines @@
           audio_streams_cached_data_.GetDictionary(cache_key, &existing_dict));
       existing_dict->MergeDictionary(value);
     }
   }
 
   if (CanUpdate())
     SendUpdate(SerializeUpdate(function, value));
 }
 
 }  // namespace content