Deliver webrtc-internals updates in bulk, every 500ms at most.

content/browser/media/webrtc_internals.cc

 // Copyright (c) 2013 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/webrtc_internals.h"
 
 #include <stddef.h>
 
 #include "base/strings/string_number_conversions.h"
 #include "build/build_config.h"
@@ skipping 21 matching lines @@
   if (!dict->GetList("log", &log)) {
     log = new base::ListValue();
     if (log)
       dict->Set("log", log);
   }
   return log;
 }
 
 }  // namespace
 
+WebRTCInternals::PendingUpdate::PendingUpdate(
+    const std::string& command, scoped_ptr<base::Value> value)
+    : command_(command), value_(std::move(value)) {}
+
+WebRTCInternals::PendingUpdate::PendingUpdate(PendingUpdate&& other)
+    : command_(std::move(other.command_)),
+      value_(std::move(other.value_)) {}
+
+WebRTCInternals::PendingUpdate::~PendingUpdate() {}
+
 WebRTCInternals::WebRTCInternals()
     : audio_debug_recordings_(false),
       event_log_recordings_(false),
-      selecting_event_log_(false) {
+      selecting_event_log_(false),
+      pending_updates_queued_(false),
+      weak_factory_(this) {
 // TODO(grunell): Shouldn't all the webrtc_internals* files be excluded from the
 // build if WebRTC is disabled?
 #if defined(ENABLE_WEBRTC)
   audio_debug_recordings_file_path_ =
       GetContentClient()->browser()->GetDefaultDownloadDirectory();
   event_log_recordings_file_path_ = audio_debug_recordings_file_path_;
 
   if (audio_debug_recordings_file_path_.empty()) {
     // In this case the default path (|audio_debug_recordings_file_path_|) will
     // be empty and the platform default path will be used in the file dialog
@@ skipping 19 matching lines @@
 
 void WebRTCInternals::OnAddPeerConnection(int render_process_id,
                                           ProcessId pid,
                                           int lid,
                                           const string& url,
                                           const string& rtc_configuration,
                                           const string& constraints) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   base::DictionaryValue* dict = new base::DictionaryValue();
-  if (!dict)
-    return;
-
   dict->SetInteger("rid", render_process_id);
   dict->SetInteger("pid", static_cast<int>(pid));
   dict->SetInteger("lid", lid);
   dict->SetString("rtcConfiguration", rtc_configuration);
   dict->SetString("constraints", constraints);
   dict->SetString("url", url);
   peer_connection_data_.Append(dict);
   CreateOrReleasePowerSaveBlocker();
 
   if (observers_.might_have_observers())
-    SendUpdate("addPeerConnection", dict);
+    SendUpdate("addPeerConnection", dict->CreateDeepCopy());

[Henrik Grunell, 2016/02/08 09:52:08]

Why do you need to create a deep copy? Could the ownership own |dict| just be
transferred?

[tommi (sloooow) - chröme, 2016/02/08 13:50:23]

ownership of dict lies with peer_connection_data_ (see line 103), so we need a
copy.

[Henrik Grunell, 2016/02/09 08:18:11]

Acknowledged.

 
   if (render_process_id_set_.insert(render_process_id).second) {
     RenderProcessHost* host = RenderProcessHost::FromID(render_process_id);
     if (host)
       host->AddObserver(this);
   }
 }
 
 void WebRTCInternals::OnRemovePeerConnection(ProcessId pid, int lid) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   for (size_t i = 0; i < peer_connection_data_.GetSize(); ++i) {
     base::DictionaryValue* dict = NULL;
     peer_connection_data_.GetDictionary(i, &dict);
 
     int this_pid = 0;
     int this_lid = 0;
     dict->GetInteger("pid", &this_pid);
     dict->GetInteger("lid", &this_lid);
 
     if (this_pid != static_cast<int>(pid) || this_lid != lid)
       continue;
 
     peer_connection_data_.Remove(i, NULL);
     CreateOrReleasePowerSaveBlocker();
 
     if (observers_.might_have_observers()) {
-      base::DictionaryValue id;
-      id.SetInteger("pid", static_cast<int>(pid));
-      id.SetInteger("lid", lid);
-      SendUpdate("removePeerConnection", &id);
+      scoped_ptr<base::DictionaryValue> id(new base::DictionaryValue());
+      id->SetInteger("pid", static_cast<int>(pid));
+      id->SetInteger("lid", lid);
+      SendUpdate("removePeerConnection", std::move(id));
     }
     break;
   }
 }
 
 void WebRTCInternals::OnUpdatePeerConnection(
     ProcessId pid, int lid, const string& type, const string& value) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   for (size_t i = 0; i < peer_connection_data_.GetSize(); ++i) {
@@ skipping 17 matching lines @@
       return;
 
     double epoch_time = base::Time::Now().ToJsTime();
     string time = base::DoubleToString(epoch_time);
     log_entry->SetString("time", time);
     log_entry->SetString("type", type);
     log_entry->SetString("value", value);
     log->Append(log_entry);
 
     if (observers_.might_have_observers()) {
-      base::DictionaryValue update;
-      update.SetInteger("pid", static_cast<int>(pid));
-      update.SetInteger("lid", lid);
-      update.MergeDictionary(log_entry);
+      scoped_ptr<base::DictionaryValue> update(new base::DictionaryValue());
+      update->SetInteger("pid", static_cast<int>(pid));
+      update->SetInteger("lid", lid);
+      update->MergeDictionary(log_entry);
 
-      SendUpdate("updatePeerConnection", &update);
+      SendUpdate("updatePeerConnection", std::move(update));
     }
     return;
   }
 }
 
 void WebRTCInternals::OnAddStats(base::ProcessId pid, int lid,
                                  const base::ListValue& value) {
   if (!observers_.might_have_observers())
     return;
 
-  base::DictionaryValue dict;
-  dict.SetInteger("pid", static_cast<int>(pid));
-  dict.SetInteger("lid", lid);
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  dict->SetInteger("pid", static_cast<int>(pid));
+  dict->SetInteger("lid", lid);
 
-  base::ListValue* list = value.DeepCopy();
-  if (!list)
-    return;
+  dict->Set("reports", value.CreateDeepCopy());
 
-  dict.Set("reports", list);
-
-  SendUpdate("addStats", &dict);
+  SendUpdate("addStats", std::move(dict));
 }
 
 void WebRTCInternals::OnGetUserMedia(int rid,
                                      base::ProcessId pid,
                                      const std::string& origin,
                                      bool audio,
                                      bool video,
                                      const std::string& audio_constraints,
                                      const std::string& video_constraints) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetInteger("rid", rid);
   dict->SetInteger("pid", static_cast<int>(pid));
   dict->SetString("origin", origin);
   if (audio)
     dict->SetString("audio", audio_constraints);
   if (video)
     dict->SetString("video", video_constraints);
 
   get_user_media_requests_.Append(dict);
 
   if (observers_.might_have_observers())
-    SendUpdate("addGetUserMedia", dict);
+    SendUpdate("addGetUserMedia", dict->CreateDeepCopy());
 
   if (render_process_id_set_.insert(rid).second) {
     RenderProcessHost* host = RenderProcessHost::FromID(rid);
     if (host)
       host->AddObserver(this);
   }
 }
 
-void WebRTCInternals::AddObserver(WebRTCInternalsUIObserver *observer) {
+void WebRTCInternals::AddObserver(WebRTCInternalsUIObserver* observer) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   observers_.AddObserver(observer);
 }
 
-void WebRTCInternals::RemoveObserver(WebRTCInternalsUIObserver *observer) {
+void WebRTCInternals::RemoveObserver(WebRTCInternalsUIObserver* observer) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   observers_.RemoveObserver(observer);
 
   // Disables audio debug recordings if it is enabled and the last
   // webrtc-internals page is going away.
   if (audio_debug_recordings_ && !observers_.might_have_observers())
     DisableAudioDebugRecordings();
 }
 
 void WebRTCInternals::UpdateObserver(WebRTCInternalsUIObserver* observer) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (peer_connection_data_.GetSize() > 0)
     observer->OnUpdate("updateAllPeerConnections", &peer_connection_data_);
 
   for (base::ListValue::iterator it = get_user_media_requests_.begin();
        it != get_user_media_requests_.end();
        ++it) {
     observer->OnUpdate("addGetUserMedia", *it);
   }
 }
 
 void WebRTCInternals::EnableAudioDebugRecordings(
     content::WebContents* web_contents) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 #if defined(ENABLE_WEBRTC)
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 #if defined(OS_ANDROID)
   EnableAudioDebugRecordingsOnAllRenderProcessHosts();
 #else
   selecting_event_log_ = false;
   DCHECK(select_file_dialog_ == nullptr);
   select_file_dialog_ = ui::SelectFileDialog::Create(this, NULL);
   select_file_dialog_->SelectFile(
       ui::SelectFileDialog::SELECT_SAVEAS_FILE,
       base::string16(),
       audio_debug_recordings_file_path_,
       NULL,
       0,
       FILE_PATH_LITERAL(""),
       web_contents->GetTopLevelNativeWindow(),
       NULL);
 #endif
 #endif
 }
 
 void WebRTCInternals::DisableAudioDebugRecordings() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 #if defined(ENABLE_WEBRTC)
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   audio_debug_recordings_ = false;
 
   // Tear down the dialog since the user has unchecked the audio debug
   // recordings box.
   select_file_dialog_ = NULL;
 
   for (RenderProcessHost::iterator i(
            content::RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance()) {
     i.GetCurrentValue()->DisableAudioDebugRecordings();
@@ skipping 57 matching lines @@
 
 void WebRTCInternals::ResetForTesting() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   observers_.Clear();
   peer_connection_data_.Clear();
   CreateOrReleasePowerSaveBlocker();
   get_user_media_requests_.Clear();
   audio_debug_recordings_ = false;
 }
 
-void WebRTCInternals::SendUpdate(const string& command, base::Value* value) {
+void WebRTCInternals::SendUpdate(const string& command,
+                                 scoped_ptr<base::Value> value) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(observers_.might_have_observers());
 
-  FOR_EACH_OBSERVER(WebRTCInternalsUIObserver,
-                    observers_,
-                    OnUpdate(command, value));
+  pending_updates_.push(PendingUpdate(command, std::move(value)));
+
+  if (!pending_updates_queued_) {

[Henrik Grunell, 2016/02/08 09:52:08]

Could you just check is queue is empty? (Before pushing of course.)

[tommi (sloooow) - chröme, 2016/02/08 13:50:23]

We won't be empty on entry in many cases. E.g. in the example case from the bug,
we might have tens of queued up updates already when the method is called.

[Henrik Grunell, 2016/02/09 08:18:11]

I don't really understand how this works I guess. Isn't this the only place were
updates are pushed to the queue? If that's the case, we'll always post the task
when the first update is pushed, no?

[tommi (sloooow) - chröme, 2016/02/09 09:34:16]

Ah yes of course you're right, sorry I didn't get it the first time.  Since
we're always on the UI thread we don't need the extra bool. Done.

[Henrik Grunell, 2016/02/09 11:47:47]

Acknowledged.

+    BrowserThread::PostDelayedTask(BrowserThread::UI, FROM_HERE,
+        base::Bind(&WebRTCInternals::ProcessPendingUpdates,
+                   weak_factory_.GetWeakPtr()),
+                   base::TimeDelta::FromMilliseconds(500));
+    pending_updates_queued_ = true;
+  }
 }
 
 void WebRTCInternals::RenderProcessHostDestroyed(RenderProcessHost* host) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   OnRendererExit(host->GetID());
 
   render_process_id_set_.erase(host->GetID());
   host->RemoveObserver(this);
 }
 
@@ skipping 34 matching lines @@
 
     int this_rid = 0;
     record->GetInteger("rid", &this_rid);
 
     if (this_rid == render_process_id) {
       if (observers_.might_have_observers()) {
         int lid = 0, pid = 0;
         record->GetInteger("lid", &lid);
         record->GetInteger("pid", &pid);
 
-        base::DictionaryValue update;
-        update.SetInteger("lid", lid);
-        update.SetInteger("pid", pid);
-        SendUpdate("removePeerConnection", &update);
+        scoped_ptr<base::DictionaryValue> update(new base::DictionaryValue());
+        update->SetInteger("lid", lid);
+        update->SetInteger("pid", pid);
+        SendUpdate("removePeerConnection", std::move(update));
       }
       peer_connection_data_.Remove(i, NULL);
     }
   }
   CreateOrReleasePowerSaveBlocker();
 
   bool found_any = false;
   // Iterates from the end of the list to remove the getUserMedia requests
   // created by the exiting renderer.
   for (int i = get_user_media_requests_.GetSize() - 1; i >= 0; --i) {
     base::DictionaryValue* record = NULL;
     get_user_media_requests_.GetDictionary(i, &record);
 
     int this_rid = 0;
     record->GetInteger("rid", &this_rid);
 
     if (this_rid == render_process_id) {
       get_user_media_requests_.Remove(i, NULL);
       found_any = true;
     }
   }
 
   if (found_any && observers_.might_have_observers()) {
-    base::DictionaryValue update;
-    update.SetInteger("rid", render_process_id);
-    SendUpdate("removeGetUserMediaForRenderer", &update);
+    scoped_ptr<base::DictionaryValue> update(new base::DictionaryValue());
+    update->SetInteger("rid", render_process_id);
+    SendUpdate("removeGetUserMediaForRenderer", std::move(update));
   }
 }
 
 #if defined(ENABLE_WEBRTC)
 void WebRTCInternals::EnableAudioDebugRecordingsOnAllRenderProcessHosts() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   audio_debug_recordings_ = true;
   for (RenderProcessHost::iterator i(
            content::RenderProcessHost::AllHostsIterator());
@@ skipping 25 matching lines @@
     power_save_blocker_.reset();
   } else if (!peer_connection_data_.empty() && !power_save_blocker_) {
     DVLOG(1) << ("Preventing the application from being suspended while one or "
                  "more PeerConnections are active.");
     power_save_blocker_ = content::PowerSaveBlocker::Create(
         PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension,
         PowerSaveBlocker::kReasonOther, "WebRTC has active PeerConnections");
   }
 }
 
+void WebRTCInternals::ProcessPendingUpdates() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  while (!pending_updates_.empty()) {
+    const auto& update = pending_updates_.front();
+    FOR_EACH_OBSERVER(WebRTCInternalsUIObserver,
+                      observers_,
+                      OnUpdate(update.command(), update.value()));
+    pending_updates_.pop();
+  }
+  pending_updates_queued_ = false;
+}
+
 }  // namespace content