Not for submission. Keeping media log events

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 246 matching lines @@
   void Observe(int type,
                const NotificationSource& source,
                const NotificationDetails& details) override;
 
   // Reports the pipeline status to UMA for every player
   // associated with the renderer process and then deletes the player state.
   void LogAndClearPlayersInRenderer(int render_process_id);
 
   // Helper function to save the event payload to RendererPlayerMap.
   void SavePlayerState(const media::MediaLogEvent& event,
+                       const base::string16& event_serialized,
                        int render_process_id);
 
+  std::vector<base::string16> GetHistoricalEvents();
+
  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;
+    // Remember media log events so that when a new media internals page is
+    // opened they can be replayed.
+    std::vector<base::string16> media_log_event_history;
     PipelineInfo()
         : last_pipeline_status(media::PIPELINE_OK),
           has_audio(false),
           has_video(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);
@@ skipping 25 matching lines @@
     const NotificationSource& source,
     const NotificationDetails& details) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(type, NOTIFICATION_RENDERER_PROCESS_TERMINATED);
   RenderProcessHost* process = Source<RenderProcessHost>(source).ptr();
 
   // Post the task to the IO thread to avoid race in updating renderer_info_ map
   // by both SavePlayerState & LogAndClearPlayersInRenderer from different
   // threads.
   // Using base::Unretained() on MediaInternalsUMAHandler is safe since
-  // it is owned by MediaInternals and share the same lifetime
+  // it is owned by MediaInternals and shares the same lifetime.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&MediaInternalsUMAHandler::LogAndClearPlayersInRenderer,
                  base::Unretained(this), process->GetID()));
 }
 
 void MediaInternals::MediaInternalsUMAHandler::SavePlayerState(
     const media::MediaLogEvent& event,
+    const base::string16& event_serialized,
     int render_process_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   PlayerInfoMap& player_info = renderer_info_[render_process_id];
+  // This can grow unbounded..
+  player_info[event.id].media_log_event_history.push_back(event_serialized);
   switch (event.type) {
     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")) {
@@ skipping 97 matching lines @@
     int render_process_id) {
   DCHECK_CURRENTLY_ON(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()) {
     ReportUMAForPipelineStatus(it->second);
     players_it->second.erase(it++);
   }
+  renderer_info_.erase(players_it);
+}
+
+std::vector<base::string16>
+MediaInternals::MediaInternalsUMAHandler::GetHistoricalEvents() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  std::vector<base::string16> all_events;
+  for (const auto& renderer_info_it : renderer_info_) {
+    for (const auto& player_info_it : renderer_info_it.second) {
+      const auto& player_events = player_info_it.second.media_log_event_history;
+      all_events.insert(all_events.end(), player_events.begin(),
+                        player_events.end());
+    }
+  }
+
+  return all_events;
 }
 
 MediaInternals* MediaInternals::GetInstance() {
   return g_media_internals.Pointer();
 }
 
 MediaInternals::MediaInternals()
     : owner_ids_(), uma_handler_(new MediaInternalsUMAHandler()) {
 }
 
@@ skipping 23 matching lines @@
           status > static_cast<int>(media::PIPELINE_STATUS_MAX)) {
         continue;
       }
       media::PipelineStatus error = static_cast<media::PipelineStatus>(status);
       dict.SetString("params.pipeline_error",
                      media::MediaLog::PipelineStatusToString(error));
     } else {
       dict.Set("params", event->params.DeepCopy());
     }
 
-    SendUpdate(SerializeUpdate("media.onMediaEvent", &dict));
-    uma_handler_->SavePlayerState(*event, render_process_id);
+    const base::string16 update(SerializeUpdate("media.onMediaEvent", &dict));
+    SendUpdate(update);
+    uma_handler_->SavePlayerState(*event, update, render_process_id);
   }
 }
 
 void MediaInternals::AddUpdateCallback(const UpdateCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   update_callbacks_.push_back(callback);
 }
 
 void MediaInternals::RemoveUpdateCallback(const UpdateCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   for (size_t i = 0; i < update_callbacks_.size(); ++i) {
     if (update_callbacks_[i].Equals(callback)) {
       update_callbacks_.erase(update_callbacks_.begin() + i);
       return;
     }
   }
   NOTREACHED();
 }
 
+void MediaInternals::SendHistoricalMediaEvents() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  for (const auto& event : uma_handler_->GetHistoricalEvents())
+    SendUpdate(event);
+}
+
 void MediaInternals::SendAudioStreamData() {
   base::string16 audio_stream_update;
   {
     base::AutoLock auto_lock(lock_);
     audio_stream_update = SerializeUpdate(
         "media.onReceiveAudioStreamData", &audio_streams_cached_data_);
   }
   SendUpdate(audio_stream_update);
 }
 
@@ skipping 80 matching lines @@
       CHECK(
           audio_streams_cached_data_.GetDictionary(cache_key, &existing_dict));
       existing_dict->MergeDictionary(value);
     }
   }
 
   SendUpdate(SerializeUpdate(function, value));
 }
 
 }  // namespace content