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 "base/path_service.h"
   8 #include "base/strings/string_number_conversions.h"
   9 #include "content/browser/media/webrtc_internals_ui_observer.h"
  10 #include "content/browser/web_contents/web_contents_view.h"
  11 #include "content/public/browser/browser_thread.h"
  12 #include "content/public/browser/content_browser_client.h"
  13 #include "content/public/browser/notification_service.h"
  14 #include "content/public/browser/notification_types.h"
  15 #include "content/public/browser/power_save_blocker.h"
  16 #include "content/public/browser/render_process_host.h"
  17 #include "content/public/browser/web_contents.h"
  18
  19 using base::ProcessId;
  20 using std::string;
  21
  22 namespace content {
  23
  24 namespace {
  25
  26 static base::LazyInstance<WebRTCInternals>::Leaky g_webrtc_internals =
  27     LAZY_INSTANCE_INITIALIZER;
  28
  29 // Makes sure that |dict| has a ListValue under path "log".
  30 static base::ListValue* EnsureLogList(base::DictionaryValue* dict) {
  31   base::ListValue* log = NULL;
  32   if (!dict->GetList("log", &log)) {
  33     log = new base::ListValue();
  34     if (log)
  35       dict->Set("log", log);
  36   }
  37   return log;
  38 }
  39
  40 }  // namespace
  41
  42 WebRTCInternals::WebRTCInternals()
  43     : aec_dump_enabled_(false) {
  44   registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_TERMINATED,
  45                  NotificationService::AllBrowserContextsAndSources());
  46 // TODO(grunell): Shouldn't all the webrtc_internals* files be excluded from the
  47 // build if WebRTC is disabled?
  48 #if defined(ENABLE_WEBRTC)
  49   aec_dump_file_path_ =
  50       GetContentClient()->browser()->GetDefaultDownloadDirectory();
  51   if (aec_dump_file_path_.empty()) {
  52     // In this case the default path (|aec_dump_file_path_|) will be empty and
  53     // the platform default path will be used in the file dialog (with no
  54     // default file name). See SelectFileDialog::SelectFile. On Android where
  55     // there's no dialog we'll fail to open the file.
  56     VLOG(1) << "Could not get the download directory.";
  57   } else {
  58     aec_dump_file_path_ =
  59         aec_dump_file_path_.Append(FILE_PATH_LITERAL("audio.aecdump"));
  60   }
  61 #endif  // defined(ENABLE_WEBRTC)
  62 }
  63
  64 WebRTCInternals::~WebRTCInternals() {
  65 }
  66
  67 WebRTCInternals* WebRTCInternals::GetInstance() {
  68   return g_webrtc_internals.Pointer();
  69 }
  70
  71 void WebRTCInternals::OnAddPeerConnection(int render_process_id,
  72                                           ProcessId pid,
  73                                           int lid,
  74                                           const string& url,
  75                                           const string& rtc_configuration,
  76                                           const string& constraints) {
  77   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  78
  79   base::DictionaryValue* dict = new base::DictionaryValue();
  80   if (!dict)
  81     return;
  82
  83   dict->SetInteger("rid", render_process_id);
  84   dict->SetInteger("pid", static_cast<int>(pid));
  85   dict->SetInteger("lid", lid);
  86   dict->SetString("rtcConfiguration", rtc_configuration);
  87   dict->SetString("constraints", constraints);
  88   dict->SetString("url", url);
  89   peer_connection_data_.Append(dict);
  90   CreateOrReleasePowerSaveBlocker();
  91
  92   if (observers_.might_have_observers())
  93     SendUpdate("addPeerConnection", dict);
  94 }
  95
  96 void WebRTCInternals::OnRemovePeerConnection(ProcessId pid, int lid) {
  97   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  98   for (size_t i = 0; i < peer_connection_data_.GetSize(); ++i) {
  99     base::DictionaryValue* dict = NULL;
 100     peer_connection_data_.GetDictionary(i, &dict);
 101
 102     int this_pid = 0;
 103     int this_lid = 0;
 104     dict->GetInteger("pid", &this_pid);
 105     dict->GetInteger("lid", &this_lid);
 106
 107     if (this_pid != static_cast<int>(pid) || this_lid != lid)
 108       continue;
 109
 110     peer_connection_data_.Remove(i, NULL);
 111     CreateOrReleasePowerSaveBlocker();
 112
 113     if (observers_.might_have_observers()) {
 114       base::DictionaryValue id;
 115       id.SetInteger("pid", static_cast<int>(pid));
 116       id.SetInteger("lid", lid);
 117       SendUpdate("removePeerConnection", &id);
 118     }
 119     break;
 120   }
 121 }
 122
 123 void WebRTCInternals::OnUpdatePeerConnection(
 124     ProcessId pid, int lid, const string& type, const string& value) {
 125   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 126
 127   for (size_t i = 0; i < peer_connection_data_.GetSize(); ++i) {
 128     base::DictionaryValue* record = NULL;
 129     peer_connection_data_.GetDictionary(i, &record);
 130
 131     int this_pid = 0, this_lid = 0;
 132     record->GetInteger("pid", &this_pid);
 133     record->GetInteger("lid", &this_lid);
 134
 135     if (this_pid != static_cast<int>(pid) || this_lid != lid)
 136       continue;
 137
 138     // Append the update to the end of the log.
 139     base::ListValue* log = EnsureLogList(record);
 140     if (!log)
 141       return;
 142
 143     base::DictionaryValue* log_entry = new base::DictionaryValue();
 144     if (!log_entry)
 145       return;
 146
 147     double epoch_time = base::Time::Now().ToJsTime();
 148     string time = base::DoubleToString(epoch_time);
 149     log_entry->SetString("time", time);
 150     log_entry->SetString("type", type);
 151     log_entry->SetString("value", value);
 152     log->Append(log_entry);
 153
 154     if (observers_.might_have_observers()) {
 155       base::DictionaryValue update;
 156       update.SetInteger("pid", static_cast<int>(pid));
 157       update.SetInteger("lid", lid);
 158       update.MergeDictionary(log_entry);
 159
 160       SendUpdate("updatePeerConnection", &update);
 161     }
 162     return;
 163   }
 164 }
 165
 166 void WebRTCInternals::OnAddStats(base::ProcessId pid, int lid,
 167                                  const base::ListValue& value) {
 168   if (!observers_.might_have_observers())
 169     return;
 170
 171   base::DictionaryValue dict;
 172   dict.SetInteger("pid", static_cast<int>(pid));
 173   dict.SetInteger("lid", lid);
 174
 175   base::ListValue* list = value.DeepCopy();
 176   if (!list)
 177     return;
 178
 179   dict.Set("reports", list);
 180
 181   SendUpdate("addStats", &dict);
 182 }
 183
 184 void WebRTCInternals::OnGetUserMedia(int rid,
 185                                      base::ProcessId pid,
 186                                      const std::string& origin,
 187                                      bool audio,
 188                                      bool video,
 189                                      const std::string& audio_constraints,
 190                                      const std::string& video_constraints) {
 191   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 192
 193   base::DictionaryValue* dict = new base::DictionaryValue();
 194   dict->SetInteger("rid", rid);
 195   dict->SetInteger("pid", static_cast<int>(pid));
 196   dict->SetString("origin", origin);
 197   if (audio)
 198     dict->SetString("audio", audio_constraints);
 199   if (video)
 200     dict->SetString("video", video_constraints);
 201
 202   get_user_media_requests_.Append(dict);
 203
 204   if (observers_.might_have_observers())
 205     SendUpdate("addGetUserMedia", dict);
 206 }
 207
 208 void WebRTCInternals::AddObserver(WebRTCInternalsUIObserver *observer) {
 209   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 210   observers_.AddObserver(observer);
 211 }
 212
 213 void WebRTCInternals::RemoveObserver(WebRTCInternalsUIObserver *observer) {
 214   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 215   observers_.RemoveObserver(observer);
 216
 217   // Disables the AEC recording if it is enabled and the last webrtc-internals
 218   // page is going away.
 219   if (aec_dump_enabled_ && !observers_.might_have_observers())
 220     DisableAecDump();
 221 }
 222
 223 void WebRTCInternals::UpdateObserver(WebRTCInternalsUIObserver* observer) {
 224   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 225   if (peer_connection_data_.GetSize() > 0)
 226     observer->OnUpdate("updateAllPeerConnections", &peer_connection_data_);
 227
 228   for (base::ListValue::iterator it = get_user_media_requests_.begin();
 229        it != get_user_media_requests_.end();
 230        ++it) {
 231     observer->OnUpdate("addGetUserMedia", *it);
 232   }
 233 }
 234
 235 void WebRTCInternals::EnableAecDump(content::WebContents* web_contents) {
 236 #if defined(ENABLE_WEBRTC)
 237 #if defined(OS_ANDROID)
 238   EnableAecDumpOnAllRenderProcessHosts();
 239 #else
 240   select_file_dialog_ = ui::SelectFileDialog::Create(this, NULL);
 241   select_file_dialog_->SelectFile(
 242       ui::SelectFileDialog::SELECT_SAVEAS_FILE,
 243       base::string16(),
 244       aec_dump_file_path_,
 245       NULL,
 246       0,
 247       FILE_PATH_LITERAL(""),
 248       web_contents->GetTopLevelNativeWindow(),
 249       NULL);
 250 #endif
 251 #endif
 252 }
 253
 254 void WebRTCInternals::DisableAecDump() {
 255 #if defined(ENABLE_WEBRTC)
 256   aec_dump_enabled_ = false;
 257
 258   // Tear down the dialog since the user has unchecked the AEC dump box.
 259   select_file_dialog_ = NULL;
 260
 261   for (RenderProcessHost::iterator i(
 262            content::RenderProcessHost::AllHostsIterator());
 263        !i.IsAtEnd(); i.Advance()) {
 264     i.GetCurrentValue()->DisableAecDump();
 265   }
 266 #endif
 267 }
 268
 269 void WebRTCInternals::ResetForTesting() {
 270   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 271   observers_.Clear();
 272   peer_connection_data_.Clear();
 273   CreateOrReleasePowerSaveBlocker();
 274   get_user_media_requests_.Clear();
 275   aec_dump_enabled_ = false;
 276 }
 277
 278 void WebRTCInternals::SendUpdate(const string& command, base::Value* value) {
 279   DCHECK(observers_.might_have_observers());
 280
 281   FOR_EACH_OBSERVER(WebRTCInternalsUIObserver,
 282                     observers_,
 283                     OnUpdate(command, value));
 284 }
 285
 286 void WebRTCInternals::Observe(int type,
 287                               const NotificationSource& source,
 288                               const NotificationDetails& details) {
 289   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 290   DCHECK_EQ(type, NOTIFICATION_RENDERER_PROCESS_TERMINATED);
 291   OnRendererExit(Source<RenderProcessHost>(source)->GetID());
 292 }
 293
 294 void WebRTCInternals::FileSelected(const base::FilePath& path,
 295                                    int /* unused_index */,
 296                                    void* /*unused_params */) {
 297 #if defined(ENABLE_WEBRTC)
 298   aec_dump_file_path_ = path;
 299   EnableAecDumpOnAllRenderProcessHosts();
 300 #endif
 301 }
 302
 303 void WebRTCInternals::FileSelectionCanceled(void* params) {
 304 #if defined(ENABLE_WEBRTC)
 305   SendUpdate("aecRecordingFileSelectionCancelled", NULL);
 306 #endif
 307 }
 308
 309 void WebRTCInternals::OnRendererExit(int render_process_id) {
 310   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 311
 312   // Iterates from the end of the list to remove the PeerConnections created
 313   // by the exitting renderer.
 314   for (int i = peer_connection_data_.GetSize() - 1; i >= 0; --i) {
 315     base::DictionaryValue* record = NULL;
 316     peer_connection_data_.GetDictionary(i, &record);
 317
 318     int this_rid = 0;
 319     record->GetInteger("rid", &this_rid);
 320
 321     if (this_rid == render_process_id) {
 322       if (observers_.might_have_observers()) {
 323         int lid = 0, pid = 0;
 324         record->GetInteger("lid", &lid);
 325         record->GetInteger("pid", &pid);
 326
 327         base::DictionaryValue update;
 328         update.SetInteger("lid", lid);
 329         update.SetInteger("pid", pid);
 330         SendUpdate("removePeerConnection", &update);
 331       }
 332       peer_connection_data_.Remove(i, NULL);
 333     }
 334   }
 335   CreateOrReleasePowerSaveBlocker();
 336
 337   bool found_any = false;
 338   // Iterates from the end of the list to remove the getUserMedia requests
 339   // created by the exiting renderer.
 340   for (int i = get_user_media_requests_.GetSize() - 1; i >= 0; --i) {
 341     base::DictionaryValue* record = NULL;
 342     get_user_media_requests_.GetDictionary(i, &record);
 343
 344     int this_rid = 0;
 345     record->GetInteger("rid", &this_rid);
 346
 347     if (this_rid == render_process_id) {
 348       get_user_media_requests_.Remove(i, NULL);
 349       found_any = true;
 350     }
 351   }
 352
 353   if (found_any && observers_.might_have_observers()) {
 354     base::DictionaryValue update;
 355     update.SetInteger("rid", render_process_id);
 356     SendUpdate("removeGetUserMediaForRenderer", &update);
 357   }
 358 }
 359
 360 #if defined(ENABLE_WEBRTC)
 361 void WebRTCInternals::EnableAecDumpOnAllRenderProcessHosts() {
 362   aec_dump_enabled_ = true;
 363   for (RenderProcessHost::iterator i(
 364            content::RenderProcessHost::AllHostsIterator());
 365        !i.IsAtEnd(); i.Advance()) {
 366     i.GetCurrentValue()->EnableAecDump(aec_dump_file_path_);
 367   }
 368 }
 369 #endif
 370
 371 void WebRTCInternals::CreateOrReleasePowerSaveBlocker() {
 372   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 373
 374   if (peer_connection_data_.empty() && power_save_blocker_) {
 375     DVLOG(1) << ("Releasing the block on application suspension since no "
 376                  "PeerConnections are active anymore.");
 377     power_save_blocker_.reset();
 378   } else if (!peer_connection_data_.empty() && !power_save_blocker_) {
 379     DVLOG(1) << ("Preventing the application from being suspended while one or "
 380                  "more PeerConnections are active.");
 381     power_save_blocker_ = content::PowerSaveBlocker::Create(
 382         content::PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension,
 383         "WebRTC has active PeerConnections.").Pass();
 384   }
 385 }
 386
 387 }  // namespace content