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

content/browser/media/webrtc/webrtc_eventlog_host.cc

+// Copyright 2016 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_eventlog_host.h"
+
+#include <algorithm>
+#include <string>
+
+#include "base/files/file_util.h"
+#include "base/strings/string_number_conversions.h"
+#include "content/browser/media/webrtc/webrtc_internals.h"
+#include "content/common/media/peer_connection_tracker_messages.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_process_host.h"
+
+#if defined(OS_WIN)
+#define IntToStringType base::IntToString16
+#else
+#define IntToStringType base::IntToString
+#endif
+
+namespace content {
+
+int WebRTCEventLogHost::number_active_log_files_ = 0;
+
+namespace {
+
+// In addition to the limit to the number of files given below, the size of the
+// files is also capped, see content/renderer/media/peer_connection_tracker.cc.
+#if defined(OS_ANDROID)
+const int kMaxNumberLogFiles = 3;
+#else
+const int kMaxNumberLogFiles = 5;
+#endif
+
+// Appends the IDs to the RTC event log file name.
+base::FilePath GetWebRtcEventLogPath(const base::FilePath& base_file,
+                                     int render_process_id,
+                                     int connection_id) {
+  return base_file.AddExtension(IntToStringType(render_process_id))
+      .AddExtension(IntToStringType(connection_id));
+}
+
+// Opens a logfile to pass on to the renderer.
+IPC::PlatformFileForTransit CreateFileForProcess(
+    const base::FilePath& base_path,
+    int render_process_id,
+    int connection_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::FilePath file_path =
+      GetWebRtcEventLogPath(base_path, render_process_id, connection_id);
+  base::File event_log_file(
+      file_path, base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
+  if (!event_log_file.IsValid()) {
+    PLOG(ERROR) << "Could not open WebRTC event log file, error="
+                << event_log_file.error_details();
+    return IPC::InvalidPlatformFileForTransit();
+  }
+  return IPC::TakePlatformFileForTransit(std::move(event_log_file));
+}
+
+}  // namespace
+
+WebRTCEventLogHost::WebRTCEventLogHost(int render_process_id)
+    : render_process_id_(render_process_id),
+      rtc_event_logging_enabled_(false),
+      weak_ptr_factory_(this) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  auto webrtc_internals = WebRTCInternals::GetInstance();
+  if (webrtc_internals->IsEventLogRecordingsEnabled())
+    StartWebRTCEventLog(webrtc_internals->GetEventLogFilePath());
+}
+
+WebRTCEventLogHost::~WebRTCEventLogHost() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+}
+
+void WebRTCEventLogHost::PeerConnectionAdded(int peer_connection_local_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(std::find(active_peer_connection_local_ids_.begin(),
+                   active_peer_connection_local_ids_.end(),
+                   peer_connection_local_id) ==
+         active_peer_connection_local_ids_.end());
+  active_peer_connection_local_ids_.push_back(peer_connection_local_id);
+  if (rtc_event_logging_enabled_ &&
+      number_active_log_files_ < kMaxNumberLogFiles) {
+    StartEventLogForPeerConnection(peer_connection_local_id);
+  }
+}
+
+void WebRTCEventLogHost::PeerConnectionRemoved(int peer_connection_local_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  const auto found = std::find(active_peer_connection_local_ids_.begin(),
+                               active_peer_connection_local_ids_.end(),
+                               peer_connection_local_id);
+  DCHECK(found != active_peer_connection_local_ids_.end());
+  active_peer_connection_local_ids_.erase(found);
+}
+
+bool WebRTCEventLogHost::StartWebRTCEventLog(const base::FilePath& file_path) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (rtc_event_logging_enabled_)
+    return false;
+  rtc_event_logging_enabled_ = true;
+  base_file_path_ = file_path;
+  for (int local_id : active_peer_connection_local_ids_)
+    StartEventLogForPeerConnection(local_id);
+  return true;
+}
+
+bool WebRTCEventLogHost::StopWebRTCEventLog() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (!rtc_event_logging_enabled_)
+    return false;
+  number_active_log_files_ = 0;
+  rtc_event_logging_enabled_ = false;
+  RenderProcessHost* host = RenderProcessHost::FromID(render_process_id_);
+  if (host) {
+    for (int local_id : active_peer_connection_local_ids_)
+      host->Send(new PeerConnectionTracker_StopEventLog(local_id));
+  }
+  return true;
+}
+
+bool WebRTCEventLogHost::StartEventLogForPeerConnection(
+    int peer_connection_local_id) {
+  if (number_active_log_files_ < kMaxNumberLogFiles) {
+    ++number_active_log_files_;
+    BrowserThread::PostTaskAndReplyWithResult(
+        BrowserThread::FILE, FROM_HERE,
+        base::Bind(&CreateFileForProcess, base_file_path_, render_process_id_,
+                   peer_connection_local_id),
+        base::Bind(&WebRTCEventLogHost::SendEventLogFileToRenderer,
+                   weak_ptr_factory_.GetWeakPtr(), peer_connection_local_id));
+  }
+  return true;
+}
+
+void WebRTCEventLogHost::SendEventLogFileToRenderer(
+    int peer_connection_local_id,
+    IPC::PlatformFileForTransit file_for_transit) {
+  if (file_for_transit == IPC::InvalidPlatformFileForTransit()) {
+    --number_active_log_files_;
+    return;
+  }
+  RenderProcessHost* rph = RenderProcessHost::FromID(render_process_id_);
+  if (rph) {
+    rph->Send(new PeerConnectionTracker_StartEventLog(peer_connection_local_id,
+                                                      file_for_transit));
+  } else {
+    --number_active_log_files_;
+    IPC::PlatformFileForTransitToFile(file_for_transit).Close();
+  }
+}
+
+}  // namespace content