Add a histogram for video decoder fallback.

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 "base/metrics/histogram.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
@@ skipping 182 matching lines @@
   // Helper function to save the event payload to RendererPlayerMap.
   void SavePlayerState(const media::MediaLogEvent& event,
                        int render_process_id);
 
  private:
   struct PipelineInfo {
     media::PipelineStatus last_pipeline_status;
     bool has_audio;
     bool has_video;
     bool video_dds;
+    bool video_decoder_changed;
     std::string audio_codec_name;
     std::string video_codec_name;
     std::string video_decoder;
     PipelineInfo()
         : last_pipeline_status(media::PIPELINE_OK),
           has_audio(false),
           has_video(false),
-          video_dds(false) {}
+          video_dds(false),
+          video_decoder_changed(false) {}
   };
 
   // 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);
 
   // Key is playerid
   typedef std::map<int, PipelineInfo> PlayerInfoMap;
@@ skipping 32 matching lines @@
       base::Bind(&MediaInternalsUMAHandler::LogAndClearPlayersInRenderer,
                  base::Unretained(this), process->GetID()));
 }
 
 void MediaInternals::MediaInternalsUMAHandler::SavePlayerState(
     const media::MediaLogEvent& event,
     int render_process_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   PlayerInfoMap& player_info = renderer_info_[render_process_id];
   switch (event.type) {
-    case media::MediaLogEvent::WEBMEDIAPLAYER_CREATED: {
-      // Nothing to do here
-      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;
     }
     case media::MediaLogEvent::PROPERTY_CHANGE:
       if (event.params.HasKey("found_audio_stream")) {
         event.params.GetBoolean("found_audio_stream",
                                 &player_info[event.id].has_audio);
       }
       if (event.params.HasKey("found_video_stream")) {
         event.params.GetBoolean("found_video_stream",
                                 &player_info[event.id].has_video);
       }
       if (event.params.HasKey("audio_codec_name")) {
         event.params.GetString("audio_codec_name",
                                &player_info[event.id].audio_codec_name);
       }
       if (event.params.HasKey("video_codec_name")) {
         event.params.GetString("video_codec_name",
                                &player_info[event.id].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);
+        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);
       }
       break;
     default:
       break;
   }
   return;
 }
@@ skipping 45 matching lines @@
                               media::PIPELINE_STATUS_MAX + 1);
   } else if (player_info.has_video) {
     UMA_HISTOGRAM_ENUMERATION("Media.PipelineStatus.VideoOnly",
                               player_info.last_pipeline_status,
                               media::PIPELINE_STATUS_MAX + 1);
   } else {
     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);
+  }
 }
 
 void MediaInternals::MediaInternalsUMAHandler::LogAndClearPlayersInRenderer(
     int render_process_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   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()) {
@@ skipping 146 matching lines @@
     const std::string& function,
     const base::DictionaryValue* value) {
   SendUpdate(SerializeUpdate(function, value));
 
   base::AutoLock auto_lock(lock_);
   scoped_ptr<base::Value> out_value;
   CHECK(audio_streams_cached_data_.Remove(cache_key, &out_value));
 }
 
 }  // namespace content