media-internals: Store updates when cannot update.

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"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/notification_observer.h"
-#include "content/public/browser/notification_registrar.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/audio/audio_parameters.h"
 #include "media/base/media_log_event.h"
 #include "media/filters/decrypting_video_decoder.h"
 #include "media/filters/gpu_video_decoder.h"
@@ skipping 218 matching lines @@
                                        kAudioLogUpdateFunction, &dict);
 }
 
 void AudioLogImpl::StoreComponentMetadata(int component_id,
                                           base::DictionaryValue* dict) {
   dict->SetInteger("owner_id", owner_id_);
   dict->SetInteger("component_id", component_id);
   dict->SetInteger("component_type", component_);
 }
 
-class MediaInternals::MediaInternalsUMAHandler : public NotificationObserver {
+class MediaInternals::MediaInternalsUMAHandler {
  public:
   MediaInternalsUMAHandler();
 
-  // NotificationObserver implementation.
-  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);
+  // 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(const media::MediaLogEvent& event,
-                       int render_process_id);
+  void SavePlayerState(int render_process_id,
+                       const media::MediaLogEvent& event);
 
  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;
@@ skipping 14 matching lines @@
 
   // Key is playerid
   typedef std::map<int, PipelineInfo> PlayerInfoMap;
 
   // Key is renderer id
   typedef std::map<int, PlayerInfoMap> RendererPlayerMap;
 
   // Stores player information per renderer
   RendererPlayerMap renderer_info_;
 
-  NotificationRegistrar registrar_;
-
   DISALLOW_COPY_AND_ASSIGN(MediaInternalsUMAHandler);
 };
 
 MediaInternals::MediaInternalsUMAHandler::MediaInternalsUMAHandler() {
-  registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_TERMINATED,
-                 NotificationService::AllBrowserContextsAndSources());
-}
-
-void MediaInternals::MediaInternalsUMAHandler::Observe(
-    int type,
-    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
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&MediaInternalsUMAHandler::LogAndClearPlayersInRenderer,
-                 base::Unretained(this), process->GetID()));
 }
 
 void MediaInternals::MediaInternalsUMAHandler::SavePlayerState(
-    const media::MediaLogEvent& event,
-    int render_process_id) {
+    int render_process_id,
+    const media::MediaLogEvent& event) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   PlayerInfoMap& player_info = renderer_info_[render_process_id];
   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;
     }
@@ skipping 88 matching lines @@
                               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(
+void MediaInternals::MediaInternalsUMAHandler::OnProcessTerminated(
     int render_process_id) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  // Ensures to run on the IO thread to avoid race in |updating renderer_info_|
+  // by both SavePlayerState and OnProcessTerminated.
+  // Using base::Unretained() on MediaInternalsUMAHandler is safe since
+  // it is owned by MediaInternals and shares the same lifetime.
+  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&MediaInternalsUMAHandler::OnProcessTerminated,
+                   base::Unretained(this), render_process_id));
+    return;
+  }
+
   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);
 }
 
 MediaInternals* MediaInternals::GetInstance() {
   return g_media_internals.Pointer();
 }
 
 MediaInternals::MediaInternals()
     : can_update_(false),
       owner_ids_(),
       uma_handler_(new MediaInternalsUMAHandler()) {
+  registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_TERMINATED,
+                 NotificationService::AllBrowserContextsAndSources());
 }
 
 MediaInternals::~MediaInternals() {}
 
+void MediaInternals::Observe(int type,
+                             const NotificationSource& source,
+                             const NotificationDetails& details) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK_EQ(type, NOTIFICATION_RENDERER_PROCESS_TERMINATED);
+  RenderProcessHost* process = Source<RenderProcessHost>(source).ptr();
+
+  uma_handler_->OnProcessTerminated(process->GetID());
+
+  base::AutoLock auto_lock(lock_);
+  pending_events_map_.erase(process->GetID());
+}
+
+// Converts the |event| to a |update|. Returns whether the conversion succeeded.
+static bool ConvertEventToUpdate(int render_process_id,
+                                 const media::MediaLogEvent& event,
+                                 base::string16* update) {
+  DCHECK(update);
+
+  base::DictionaryValue dict;
+  dict.SetInteger("renderer", render_process_id);
+  dict.SetInteger("player", event.id);
+  dict.SetString("type", media::MediaLog::EventTypeToString(event.type));
+
+  // TODO(dalecurtis): This is technically not correct.  TimeTicks "can't" be
+  // converted to to a human readable time format.  See base/time/time.h.
+  const double ticks = event.time.ToInternalValue();
+  const double ticks_millis = ticks / base::Time::kMicrosecondsPerMillisecond;
+  dict.SetDouble("ticksMillis", ticks_millis);
+
+  // Convert PipelineStatus to human readable string
+  if (event.type == media::MediaLogEvent::PIPELINE_ERROR) {
+    int status;
+    if (!event.params.GetInteger("pipeline_error", &status) ||
+        status < static_cast<int>(media::PIPELINE_OK) ||
+        status > static_cast<int>(media::PIPELINE_STATUS_MAX)) {
+      return false;
+    }
+    media::PipelineStatus error = static_cast<media::PipelineStatus>(status);
+    dict.SetString("params.pipeline_error",
+                   media::MediaLog::PipelineStatusToString(error));
+  } else {
+    dict.Set("params", event.params.DeepCopy());
+  }
+
+  *update = SerializeUpdate("media.onMediaEvent", &dict);
+  return true;
+}
+
 void MediaInternals::OnMediaEvents(
     int render_process_id, const std::vector<media::MediaLogEvent>& events) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // Notify observers that |event| has occurred.
-  for (auto event = events.begin(); event != events.end(); ++event) {
-    base::DictionaryValue dict;
-    dict.SetInteger("renderer", render_process_id);
-    dict.SetInteger("player", event->id);
-    dict.SetString("type", media::MediaLog::EventTypeToString(event->type));
-
-    // TODO(dalecurtis): This is technically not correct.  TimeTicks "can't" be
-    // converted to to a human readable time format.  See base/time/time.h.
-    const double ticks = event->time.ToInternalValue();
-    const double ticks_millis = ticks / base::Time::kMicrosecondsPerMillisecond;
-    dict.SetDouble("ticksMillis", ticks_millis);
-
-    // Convert PipelineStatus to human readable string
-    if (event->type == media::MediaLogEvent::PIPELINE_ERROR) {
-      int status;
-      if (!event->params.GetInteger("pipeline_error", &status) ||
-          status < static_cast<int>(media::PIPELINE_OK) ||
-          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());
+  for (const auto& event : events) {
+    if (CanUpdate()) {
+      base::string16 update;
+      if (ConvertEventToUpdate(render_process_id, event, &update))
+        SendUpdate(update);
     }
 
-    if (CanUpdate())
-      SendUpdate(SerializeUpdate("media.onMediaEvent", &dict));
-    uma_handler_->SavePlayerState(*event, render_process_id);
+    SaveEvent(render_process_id, event);
+    uma_handler_->SavePlayerState(render_process_id, event);
   }
 }
 
 void MediaInternals::AddUpdateCallback(const UpdateCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   update_callbacks_.push_back(callback);
 
   base::AutoLock auto_lock(lock_);
   can_update_ = true;
 }
 
 void MediaInternals::RemoveUpdateCallback(const UpdateCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   for (size_t i = 0; i < update_callbacks_.size(); ++i) {
     if (update_callbacks_[i].Equals(callback)) {
       update_callbacks_.erase(update_callbacks_.begin() + i);
       break;
     }
   }
 
   base::AutoLock auto_lock(lock_);
   can_update_ = !update_callbacks_.empty();
 }
 
 bool MediaInternals::CanUpdate() {
   base::AutoLock auto_lock(lock_);
   return can_update_;
 }
 
+void MediaInternals::SendHistoricalMediaEvents() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  base::AutoLock auto_lock(lock_);
+  for (const auto& pending_events : pending_events_map_) {
+    for (const auto& event : pending_events.second) {
+      base::string16 update;
+      if (ConvertEventToUpdate(pending_events.first, event, &update))
+        SendUpdate(update);
+    }
+  }
+  // Do not clear the map/list here so that refreshing the UI or opening a
+  // second UI still works nicely!
+}
+
 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 54 matching lines @@
   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);
 }
 
+void MediaInternals::SaveEvent(int process_id,
+                               const media::MediaLogEvent& event) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  // Max number of saved updates allowed for one process.
+  const size_t kMaxNumEvents = 128;
+
+  // Do not save instantaneous events that happen frequently and have little
+  // value in the future.
+  if (event.type == media::MediaLogEvent::NETWORK_ACTIVITY_SET ||
+      event.type == media::MediaLogEvent::BUFFERED_EXTENTS_CHANGED) {
+    return;
+  }
+
+  base::AutoLock auto_lock(lock_);
+  auto& pending_events = pending_events_map_[process_id];
+  // TODO(xhwang): Notify user that some old logs could have been truncated.
+  // See http://crbug.com/498520
+  if (pending_events.size() >= kMaxNumEvents)
+    pending_events.pop_front();
+  pending_events.push_back(event);
+}
+
 void MediaInternals::SendAudioLogUpdate(AudioLogUpdateType type,
                                         const std::string& cache_key,
                                         const std::string& function,
                                         const base::DictionaryValue* value) {
   if (!CanUpdate())
     return;
 
   {
     base::AutoLock auto_lock(lock_);
     const bool has_entry = audio_streams_cached_data_.HasKey(cache_key);
@@ skipping 10 matching lines @@
       CHECK(
           audio_streams_cached_data_.GetDictionary(cache_key, &existing_dict));
       existing_dict->MergeDictionary(value);
     }
   }
 
   SendUpdate(SerializeUpdate(function, value));
 }
 
 }  // namespace content