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"
@@ skipping 303 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,
     int render_process_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 108 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);
 }
 
 MediaInternals* MediaInternals::GetInstance() {
   return g_media_internals.Pointer();
 }
 
 MediaInternals::MediaInternals()
     : can_update_(false),
       owner_ids_(),
       uma_handler_(new MediaInternalsUMAHandler()) {
@@ skipping 27 matching lines @@
       }
       media::PipelineStatus error = static_cast<media::PipelineStatus>(status);
       dict.SetString("params.pipeline_error",
                      media::MediaLog::PipelineStatusToString(error));
     } else {
       dict.Set("params", event->params.DeepCopy());
     }
 
     if (CanUpdate())
       SendUpdate(SerializeUpdate("media.onMediaEvent", &dict));
+    else
+      SaveUpdate(SerializeUpdate("media.onMediaEvent", &dict));
+
     uma_handler_->SavePlayerState(*event, render_process_id);
   }
 }
 
 void MediaInternals::AddUpdateCallback(const UpdateCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   update_callbacks_.push_back(callback);
 
   base::AutoLock auto_lock(lock_);
   can_update_ = true;
@@ skipping 10 matching lines @@
 
   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& update : pending_updates_)
+    SendUpdate(update);
+  pending_updates_.clear();
+}
+
 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::SaveUpdate(const base::string16& update) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  static const size_t kMaxNumUpdates = 2048;

[DaleCurtis, 2015/06/09 16:41:32]

Usually just const at function scope.

[xhwang, 2015/06/09 20:37:57]

Done.

+
+  base::AutoLock auto_lock(lock_);
+  if (pending_updates_.size() >= kMaxNumUpdates)
+    pending_updates_.pop_front();
+  pending_updates_.push_back(update);
+}
+
 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