Move the call to enable the WebRTC event log from PeerConnectionFactory to PeerConnection.

content/browser/media/webrtc/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/webrtc_internals.h"
 
 #include <stddef.h>
 
 #include "base/strings/string_number_conversions.h"
 #include "build/build_config.h"
 #include "content/browser/media/webrtc/webrtc_internals_ui_observer.h"
 #include "content/browser/web_contents/web_contents_view.h"
+#include "content/common/media/peer_connection_tracker_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/power_save_blocker.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
+#include "ipc/ipc_platform_file.h"
+
+#if defined(OS_WIN)
+#define IntToStringType base::IntToString16
+#else
+#define IntToStringType base::IntToString
+#endif
 
 using base::ProcessId;
 using std::string;
 
 namespace content {
 
 namespace {
 
 static base::LazyInstance<WebRTCInternals>::Leaky g_webrtc_internals =
     LAZY_INSTANCE_INITIALIZER;
 
 // Makes sure that |dict| has a ListValue under path "log".
 static base::ListValue* EnsureLogList(base::DictionaryValue* dict) {
   base::ListValue* log = NULL;
   if (!dict->GetList("log", &log)) {
     log = new base::ListValue();
     if (log)
       dict->Set("log", log);
   }
   return log;
 }
 
+#if defined(ENABLE_WEBRTC)
+// Creates a file used for handing over to the renderer.

[Henrik Grunell, 2016/04/07 09:22:33]

Webrtc internals is not the right place to handle this - it's purpose is to
handle data. You should sync up with terelius@ and his CL
https://codereview.chromium.org/1650133002/ which introduces
WebrtcEventLogHandler.

[Ivo-OOO until feb 6, 2016/04/07 12:10:50]

Thanks for pointing that out, I was not aware of this CL. It does make sense to
unify this functionality in that class (although I think it has to be extended a
bit). I will start working on that, so please don't review this CL until that is
complete.

+IPC::PlatformFileForTransit CreateFileForProcess(
+    const base::FilePath& file_path,
+    base::ProcessHandle process) {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::File event_log_file(
+      file_path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_APPEND);
+  if (!event_log_file.IsValid()) {
+    VLOG(1) << "Could not open event log file, error="
+            << event_log_file.error_details();
+    return IPC::InvalidPlatformFileForTransit();
+  }
+  return IPC::TakeFileHandleForProcess(std::move(event_log_file), process);
+}
+
+void SendEventLogFileToRenderer(int render_process_id,
+                                int local_id,
+                                IPC::PlatformFileForTransit file_for_transit) {
+#if defined(OS_ANDROID)
+  const int64_t max_file_size = 10000000;
+#else
+  const int64_t max_file_size = 30000000;
+#endif
+  if (file_for_transit == IPC::InvalidPlatformFileForTransit()) {
+    return;
+  }
+  RenderProcessHost* rph = RenderProcessHost::FromID(render_process_id);
+  if (rph) {
+    rph->Send(new PeerConnectionTracker_StartEventLog(
+        local_id, file_for_transit, max_file_size));
+  }
+}
+#endif
 }  // 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_)) {}
 
@@ skipping 10 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   return value_.get();
 }
 
 WebRTCInternals::WebRTCInternals() : WebRTCInternals(500) {}
 
 WebRTCInternals::WebRTCInternals(int aggregate_updates_ms)
     : audio_debug_recordings_(false),
       event_log_recordings_(false),
       selecting_event_log_(false),
+      number_event_log_files_(0),
       aggregate_updates_ms_(aggregate_updates_ms),
       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()) {
@@ skipping 30 matching lines @@
   base::DictionaryValue* dict = new base::DictionaryValue();
   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 (event_log_recordings_ && number_event_log_files_ > 0) {
+    number_event_log_files_--;
+    base::FilePath file_path = event_log_recordings_file_path_;
+    file_path = file_path.AddExtension(IntToStringType(render_process_id));
+    file_path = file_path.AddExtension(IntToStringType(lid));
+
+    BrowserThread::PostTaskAndReplyWithResult(
+        BrowserThread::FILE, FROM_HERE,
+        base::Bind(&CreateFileForProcess, file_path,
+                   base::GetCurrentProcessHandle()),
+        base::Bind(&SendEventLogFileToRenderer, render_process_id, lid));
+  }
+
   if (observers_.might_have_observers())
     SendUpdate("addPeerConnection", dict->CreateDeepCopy());
 
   if (render_process_id_set_.insert(render_process_id).second) {
     RenderProcessHost* host = RenderProcessHost::FromID(render_process_id);
     if (host)
       host->AddObserver(this);
   }
 }
 
@@ skipping 201 matching lines @@
     DCHECK(select_file_dialog_ == nullptr);
     selecting_event_log_ = true;
     select_file_dialog_ = ui::SelectFileDialog::Create(this, nullptr);
     select_file_dialog_->SelectFile(
         ui::SelectFileDialog::SELECT_SAVEAS_FILE, base::string16(),
         event_log_recordings_file_path_, nullptr, 0, FILE_PATH_LITERAL(""),
         web_contents->GetTopLevelNativeWindow(), nullptr);
 #endif
   } else {
     event_log_recordings_ = false;
+    number_event_log_files_ = 0;
     // Tear down the dialog since the user has unchecked the audio debug
     // recordings box.
+    DCHECK(select_file_dialog_->HasOneRef());
     select_file_dialog_ = nullptr;
-    DCHECK(select_file_dialog_->HasOneRef());
 
-    for (RenderProcessHost::iterator i(
-             content::RenderProcessHost::AllHostsIterator());
-         !i.IsAtEnd(); i.Advance()) {
-      i.GetCurrentValue()->DisableEventLogRecordings();
+    for (size_t i = 0; i < peer_connection_data_.GetSize(); ++i) {
+      base::DictionaryValue* record = NULL;
+      peer_connection_data_.GetDictionary(i, &record);
+
+      int rid, lid;
+      record->GetInteger("rid", &rid);
+      record->GetInteger("lid", &lid);
+      auto rph = RenderProcessHost::FromID(rid);
+      if (rph) {
+        rph->Send(new PeerConnectionTracker_StopEventLog(lid));
+      }
     }
   }
 #endif
 }
 
 bool WebRTCInternals::IsEventLogRecordingsEnabled() const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return event_log_recordings_;
 }
 
@@ skipping 100 matching lines @@
     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);
 
+#if defined(OS_ANDROID)
+  number_event_log_files_ = 3;
+#else
+  number_event_log_files_ = 10;
+#endif
   audio_debug_recordings_ = true;
   for (RenderProcessHost::iterator i(
            content::RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance()) {
     i.GetCurrentValue()->EnableAudioDebugRecordings(
         audio_debug_recordings_file_path_);
   }
 }
 
 void WebRTCInternals::EnableEventLogRecordingsOnAllRenderProcessHosts() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   event_log_recordings_ = true;
-  for (RenderProcessHost::iterator i(
-           content::RenderProcessHost::AllHostsIterator());
-       !i.IsAtEnd(); i.Advance()) {
-    i.GetCurrentValue()->EnableEventLogRecordings(
-        event_log_recordings_file_path_);
+  for (size_t i = 0; i < peer_connection_data_.GetSize(); ++i) {
+    if (number_event_log_files_ <= 0) {
+      VLOG(1) << "Maximum number of WebRTC event log files reached.";
+      break;
+    }
+    number_event_log_files_--;
+    base::DictionaryValue* record = NULL;
+    peer_connection_data_.GetDictionary(i, &record);
+
+    int rid, lid;
+    record->GetInteger("rid", &rid);
+    record->GetInteger("lid", &lid);
+    base::FilePath file_path = event_log_recordings_file_path_;
+    file_path = file_path.AddExtension(IntToStringType(rid));
+    file_path = file_path.AddExtension(IntToStringType(lid));
+
+    BrowserThread::PostTaskAndReplyWithResult(
+        BrowserThread::FILE, FROM_HERE,
+        base::Bind(&CreateFileForProcess, file_path,
+                   base::GetCurrentProcessHandle()),
+        base::Bind(&SendEventLogFileToRenderer, rid, lid));
   }
 }
 #endif
 
 void WebRTCInternals::CreateOrReleasePowerSaveBlocker() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (peer_connection_data_.empty() && power_save_blocker_) {
     DVLOG(1) << ("Releasing the block on application suspension since no "
                  "PeerConnections are active anymore.");
@@ skipping 12 matching lines @@
   while (!pending_updates_.empty()) {
     const auto& update = pending_updates_.front();
     FOR_EACH_OBSERVER(WebRTCInternalsUIObserver,
                       observers_,
                       OnUpdate(update.command(), update.value()));
     pending_updates_.pop();
   }
 }
 
 }  // namespace content