src/content/browser/media/webrtc_internals.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/media/webrtc_internals.h"
   6
   7 #include "content/browser/media/webrtc_internals_ui_observer.h"
   8 #include "content/public/browser/browser_thread.h"
   9 #include "content/public/browser/child_process_data.h"
  10 #include "content/public/browser/notification_service.h"
  11 #include "content/public/browser/notification_types.h"
  12 #include "content/public/browser/render_process_host.h"
  13
  14 using base::ProcessId;
  15 using std::string;
  16
  17 namespace content {
  18
  19 namespace {
  20 // Makes sure that |dict| has a ListValue under path "log".
  21 static base::ListValue* EnsureLogList(base::DictionaryValue* dict) {
  22   base::ListValue* log = NULL;
  23   if (!dict->GetList("log", &log)) {
  24     log = new base::ListValue();
  25     if (log)
  26       dict->Set("log", log);
  27   }
  28   return log;
  29 }
  30
  31 }  // namespace
  32
  33 WebRTCInternals::WebRTCInternals() : is_recording_rtp_(false) {
  34   registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_TERMINATED,
  35                  NotificationService::AllBrowserContextsAndSources());
  36
  37   BrowserChildProcessObserver::Add(this);
  38 }
  39
  40 WebRTCInternals::~WebRTCInternals() {
  41   BrowserChildProcessObserver::Remove(this);
  42 }
  43
  44 WebRTCInternals* WebRTCInternals::GetInstance() {
  45   return Singleton<WebRTCInternals>::get();
  46 }
  47
  48 void WebRTCInternals::OnAddPeerConnection(int render_process_id,
  49                                           ProcessId pid,
  50                                           int lid,
  51                                           const string& url,
  52                                           const string& servers,
  53                                           const string& constraints) {
  54   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  55
  56   base::DictionaryValue* dict = new base::DictionaryValue();
  57   if (!dict)
  58     return;
  59
  60   dict->SetInteger("rid", render_process_id);
  61   dict->SetInteger("pid", static_cast<int>(pid));
  62   dict->SetInteger("lid", lid);
  63   dict->SetString("servers", servers);
  64   dict->SetString("constraints", constraints);
  65   dict->SetString("url", url);
  66   peer_connection_data_.Append(dict);
  67
  68   if (observers_.might_have_observers())
  69     SendUpdate("addPeerConnection", dict);
  70 }
  71
  72 void WebRTCInternals::OnRemovePeerConnection(ProcessId pid, int lid) {
  73   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  74   for (size_t i = 0; i < peer_connection_data_.GetSize(); ++i) {
  75     base::DictionaryValue* dict = NULL;
  76     peer_connection_data_.GetDictionary(i, &dict);
  77
  78     int this_pid = 0;
  79     int this_lid = 0;
  80     dict->GetInteger("pid", &this_pid);
  81     dict->GetInteger("lid", &this_lid);
  82
  83     if (this_pid != static_cast<int>(pid) || this_lid != lid)
  84       continue;
  85
  86     peer_connection_data_.Remove(i, NULL);
  87
  88     if (observers_.might_have_observers()) {
  89       base::DictionaryValue id;
  90       id.SetInteger("pid", static_cast<int>(pid));
  91       id.SetInteger("lid", lid);
  92       SendUpdate("removePeerConnection", &id);
  93     }
  94     break;
  95   }
  96 }
  97
  98 void WebRTCInternals::OnUpdatePeerConnection(
  99     ProcessId pid, int lid, const string& type, const string& value) {
 100   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 101
 102   for (size_t i = 0; i < peer_connection_data_.GetSize(); ++i) {
 103     base::DictionaryValue* record = NULL;
 104     peer_connection_data_.GetDictionary(i, &record);
 105
 106     int this_pid = 0, this_lid = 0;
 107     record->GetInteger("pid", &this_pid);
 108     record->GetInteger("lid", &this_lid);
 109
 110     if (this_pid != static_cast<int>(pid) || this_lid != lid)
 111       continue;
 112
 113     // Append the update to the end of the log.
 114     base::ListValue* log = EnsureLogList(record);
 115     if (!log)
 116       return;
 117
 118     base::DictionaryValue* log_entry = new base::DictionaryValue();
 119     if (!log_entry)
 120       return;
 121
 122     log_entry->SetString("type", type);
 123     log_entry->SetString("value", value);
 124     log->Append(log_entry);
 125
 126     if (observers_.might_have_observers()) {
 127       base::DictionaryValue update;
 128       update.SetInteger("pid", static_cast<int>(pid));
 129       update.SetInteger("lid", lid);
 130       update.SetString("type", type);
 131       update.SetString("value", value);
 132
 133       SendUpdate("updatePeerConnection", &update);
 134     }
 135     return;
 136   }
 137 }
 138
 139 void WebRTCInternals::OnAddStats(base::ProcessId pid, int lid,
 140                                  const base::ListValue& value) {
 141   if (!observers_.might_have_observers())
 142     return;
 143
 144   base::DictionaryValue dict;
 145   dict.SetInteger("pid", static_cast<int>(pid));
 146   dict.SetInteger("lid", lid);
 147
 148   base::ListValue* list = value.DeepCopy();
 149   if (!list)
 150     return;
 151
 152   dict.Set("reports", list);
 153
 154   SendUpdate("addStats", &dict);
 155 }
 156
 157 void WebRTCInternals::AddObserver(WebRTCInternalsUIObserver *observer) {
 158   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 159   observers_.AddObserver(observer);
 160 }
 161
 162 void WebRTCInternals::RemoveObserver(WebRTCInternalsUIObserver *observer) {
 163   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 164   observers_.RemoveObserver(observer);
 165 }
 166
 167 void WebRTCInternals::SendAllUpdates() {
 168   if (observers_.might_have_observers())
 169     SendUpdate("updateAllPeerConnections", &peer_connection_data_);
 170 }
 171
 172 void WebRTCInternals::StartRtpRecording() {
 173   if (!is_recording_rtp_) {
 174     is_recording_rtp_ = true;
 175     // TODO(justinlin): start RTP recording.
 176   }
 177 }
 178
 179 void WebRTCInternals::StopRtpRecording() {
 180   if (is_recording_rtp_) {
 181     is_recording_rtp_ = false;
 182     // TODO(justinlin): stop RTP recording.
 183   }
 184 }
 185
 186 void WebRTCInternals::SendUpdate(const string& command, base::Value* value) {
 187   DCHECK(observers_.might_have_observers());
 188
 189   FOR_EACH_OBSERVER(WebRTCInternalsUIObserver,
 190                     observers_,
 191                     OnUpdate(command, value));
 192 }
 193
 194 void WebRTCInternals::BrowserChildProcessCrashed(
 195     const ChildProcessData& data) {
 196   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 197   OnRendererExit(data.id);
 198 }
 199
 200 void WebRTCInternals::Observe(int type,
 201                               const NotificationSource& source,
 202                               const NotificationDetails& details) {
 203   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 204   DCHECK_EQ(type, NOTIFICATION_RENDERER_PROCESS_TERMINATED);
 205   OnRendererExit(Source<RenderProcessHost>(source)->GetID());
 206 }
 207
 208 void WebRTCInternals::OnRendererExit(int render_process_id) {
 209   // Iterates from the end of the list to remove the PeerConnections created
 210   // by the exitting renderer.
 211   for (int i = peer_connection_data_.GetSize() - 1; i >= 0; --i) {
 212     base::DictionaryValue* record = NULL;
 213     peer_connection_data_.GetDictionary(i, &record);
 214
 215     int this_rid = 0;
 216     record->GetInteger("rid", &this_rid);
 217
 218     if (this_rid == render_process_id) {
 219       if (observers_.might_have_observers()) {
 220         int lid = 0, pid = 0;
 221         record->GetInteger("lid", &lid);
 222         record->GetInteger("pid", &pid);
 223
 224         base::DictionaryValue update;
 225         update.SetInteger("lid", lid);
 226         update.SetInteger("pid", pid);
 227         SendUpdate("removePeerConnection", &update);
 228       }
 229       peer_connection_data_.Remove(i, NULL);
 230     }
 231   }
 232 }
 233
 234 // TODO(justlin): Calls this method as necessary to update the recording status
 235 // UI.
 236 void WebRTCInternals::SendRtpRecordingUpdate() {
 237   DCHECK(is_recording_rtp_);
 238   base::DictionaryValue update;
 239   // TODO(justinlin): Fill in |update| with values as appropriate.
 240   SendUpdate("updateDumpStatus", &update);
 241 }
 242
 243 }  // namespace content