media: Add incognito EME playback UMA

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 <tuple>
 #include <utility>
 
 #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_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/media_log_event.h"
 #include "media/filters/gpu_video_decoder.h"
@@ skipping 54 matching lines @@
     case media::AudioParameters::AUDIO_BITSTREAM_EAC3:
       return "eac3";
     case media::AudioParameters::AUDIO_FAKE:
       return "fake";
   }
 
   NOTREACHED();
   return "unknown";
 }
 
+bool IsIncognito(int render_process_id) {

[ddorwin, 2017/04/13 16:52:59]

The function name is different from the method it calls. Should we be
consistent? Does that affect the UMA name? Is Chrome OS Guest mode included?

+  content::RenderProcessHost* render_process_host =
+      content::RenderProcessHost::FromID(render_process_id);
+  DCHECK(render_process_host);
+
+  content::BrowserContext* browser_context =
+      render_process_host->GetBrowserContext();
+  DCHECK(browser_context);
+
+  return browser_context->IsOffTheRecord();
+}
+
 const char kAudioLogStatusKey[] = "status";
 const char kAudioLogUpdateFunction[] = "media.updateAudioComponent";
 
 }  // namespace
 
 namespace content {
 
 class AudioLogImpl : public media::AudioLog {
  public:
   AudioLogImpl(int owner_id,
@@ skipping 191 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;
     base::TimeDelta embedded_experience_watch_time = media::kNoTimestamp;
   };
 
   struct PipelineInfo {
+    explicit PipelineInfo(bool is_incognito) : is_incognito(is_incognito) {}
+
     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;
+    bool has_cdm = false;
+    bool is_incognito = 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.
@@ skipping 73 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(MediaInternalsUMAHandler);
 };
 
 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];
+
+  PlayerInfoMap& player_info_map = renderer_info_[render_process_id];
+
+  auto it = player_info_map.find(event.id);
+  if (it == player_info_map.end()) {
+    bool success = false;
+    std::tie(it, success) = player_info_map.emplace(
+        std::make_pair(event.id, PipelineInfo(IsIncognito(render_process_id))));
+    if (!success) {
+      LOG(ERROR) << "Failed to insert a new PipelineInfo.";
+      return;
+    }
+  }
+
+  PipelineInfo& player_info = it->second;
+
   switch (event.type) {
     case media::MediaLogEvent::PLAY: {
-      player_info[event.id].has_ever_played = true;
+      player_info.has_ever_played = true;
       break;
     }
     case media::MediaLogEvent::PIPELINE_STATE_CHANGED: {
-      player_info[event.id].has_pipeline = true;
+      player_info.has_pipeline = true;
       break;
     }
     case media::MediaLogEvent::PIPELINE_ERROR: {
       int status;
       event.params.GetInteger("pipeline_error", &status);
-      player_info[event.id].last_pipeline_status =
+      player_info.last_pipeline_status =
           static_cast<media::PipelineStatus>(status);
       break;
     }
     case media::MediaLogEvent::PROPERTY_CHANGE:
       if (event.params.HasKey("found_audio_stream")) {
-        event.params.GetBoolean("found_audio_stream",
-                                &player_info[event.id].has_audio);
+        event.params.GetBoolean("found_audio_stream", &player_info.has_audio);
       }
       if (event.params.HasKey("found_video_stream")) {
-        event.params.GetBoolean("found_video_stream",
-                                &player_info[event.id].has_video);
+        event.params.GetBoolean("found_video_stream", &player_info.has_video);
       }
       if (event.params.HasKey("audio_codec_name")) {
         event.params.GetString("audio_codec_name",
-                               &player_info[event.id].audio_codec_name);
+                               &player_info.audio_codec_name);
       }
       if (event.params.HasKey("video_codec_name")) {
         event.params.GetString("video_codec_name",
-                               &player_info[event.id].video_codec_name);
+                               &player_info.video_codec_name);
       }
       if (event.params.HasKey("video_decoder")) {
-        std::string previous_video_decoder(player_info[event.id].video_decoder);
-        event.params.GetString("video_decoder",
-                               &player_info[event.id].video_decoder);
+        std::string previous_video_decoder(player_info.video_decoder);
+        event.params.GetString("video_decoder", &player_info.video_decoder);
         if (!previous_video_decoder.empty() &&
-            previous_video_decoder != player_info[event.id].video_decoder) {
-          player_info[event.id].video_decoder_changed = true;
+            previous_video_decoder != player_info.video_decoder) {
+          player_info.video_decoder_changed = true;
         }
       }
       if (event.params.HasKey("video_dds")) {
-        event.params.GetBoolean("video_dds", &player_info[event.id].video_dds);
+        event.params.GetBoolean("video_dds", &player_info.video_dds);
+      }
+      if (event.params.HasKey("has_cdm")) {
+        event.params.GetBoolean("has_cdm", &player_info.has_cdm);
       }
       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;
+          player_info.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;
+      WatchTimeInfo& wti = player_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,
@@ skipping 19 matching lines @@
                          &wti.ac_watch_time);
       MaybeSaveWatchTime(
           event, media::MediaLog::kWatchTimeAudioVideoEmbeddedExperience,
           &wti.embedded_experience_watch_time);
 
       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(player_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(info.has_video, &wti, FinalizeType::POWER_ONLY);
+        FinalizeWatchTime(player_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())
+      auto it = player_info_map.find(event.id);
+      if (it == player_info_map.end())
         break;
 
       ReportUMAForPipelineStatus(it->second);
-      player_info.erase(it);
+      player_info_map.erase(it);
     }
     default:
       break;
   }
   return;
 }
 
 std::string MediaInternals::MediaInternalsUMAHandler::GetUMANameForAVStream(
     const PipelineInfo& player_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 21 matching lines @@
   }
 
   if (player_info.video_decoder == media::GpuVideoDecoder::kDecoderName) {
     uma_name += "HW";
   } else {
     uma_name += "SW";
   }
   return uma_name;
 }
 
 void MediaInternals::MediaInternalsUMAHandler::ReportUMAForPipelineStatus(

[ddorwin, 2017/04/13 16:52:59]

This function name does not make it clear that it should only be called when the
player/pipeline is destroyed. Instead, it sounds like it should be called when
the status changes. We should probably rename it, though not necessarily here.

[xhwang, 2017/04/13 22:36:34]

Added a TODO.

     const PipelineInfo& player_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Don't log pipeline status for players which don't actually have a pipeline;
   // e.g., the Android MediaSourcePlayer implementation.
   if (!player_info.has_pipeline)
     return;
 
   if (player_info.has_video && player_info.has_audio) {
     base::LinearHistogram::FactoryGet(
@@ skipping 19 matching lines @@
   }
   // 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)
+  if (player_info.has_reached_have_enough) {
     UMA_HISTOGRAM_BOOLEAN("Media.HasEverPlayed", player_info.has_ever_played);
+  }
+
+  // Report whether an encrypted playback is in incognito window, excluding

[ddorwin, 2017/04/13 16:52:59]

Once we have data, we should compare the `false` numbers to our other metrics.

[xhwang, 2017/04/13 22:36:34]

Acknowledged.

+  // loaded-but-never-used players.
+  if (player_info.has_cdm && player_info.has_reached_have_enough)

[DaleCurtis, 2017/04/12 21:38:19]

Needs && player_info.has_ever_played.

[xhwang, 2017/04/13 22:36:34]

Done.

+    UMA_HISTOGRAM_BOOLEAN("Media.EME.IsIncognito", player_info.is_incognito);
 }
 
 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