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 <string>
+
+#include "base/files/file_util.h"
+#include "base/strings/string_number_conversions.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"
+#include "ipc/ipc_platform_file.h"
+
+namespace content {
+
+int WebRTCEventLogHost::number_active_log_files_ = 0;
+
+namespace {
+
+#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(base::IntToString(render_process_id))
+      .AddExtension(base::IntToString(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_OPEN_ALWAYS | base::File::FLAG_APPEND);
+  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));
+}
+
+void SendEventLogFileToRenderer(content::RenderProcessHost* rph,
+                                int local_id,
+                                IPC::PlatformFileForTransit file_for_transit) {
+  if (file_for_transit == IPC::InvalidPlatformFileForTransit())
+    return;
+
+  rph->Send(
+      new PeerConnectionTracker_StartEventLog(local_id, file_for_transit));
+}
+
+}  // namespace
+
+WebRTCEventLogHost::WebRTCEventLogHost(int render_process_id)
+    : render_process_id_(render_process_id), rtc_event_logging_enabled_(false) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+}
+
+WebRTCEventLogHost::~WebRTCEventLogHost() {}
+
+void WebRTCEventLogHost::PeerConnectionAdded(int peer_connection_local_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(active_peer_connection_local_id_.count(peer_connection_local_id) == 0);

[tommi (sloooow) - chröme, 2016/05/30 15:37:16]

It looks like unordered_set is also too complex for what you want.  I think you
just want std::vector.  In these DCHECKs, you can then just use std::find() to
make sure an element either exists or does not exist in the vector.
The reason I'm pushing back on using set and now unordered_set, btw is that if
we don't actually need the code that's behind these types, it adds to the binary
size, which increases our footprint.  We need to take care of the pennies so
that the pounds can take care of themselves.

[Ivo-OOO until feb 6, 2016/05/31 08:18:30]

Okay, that makes sense, I'll change to vector.

+  active_peer_connection_local_id_.insert(peer_connection_local_id);
+  if (rtc_event_logging_enabled_ &&
+      number_active_log_files_ < kMaxNumberLogFiles) {
+    content::RenderProcessHost* host =
+        content::RenderProcessHost::FromID(render_process_id_);
+    if (host) {
+      BrowserThread::PostTaskAndReplyWithResult(
+          BrowserThread::FILE, FROM_HERE,
+          base::Bind(&CreateFileForProcess, base_file_path_, render_process_id_,
+                     peer_connection_local_id),
+          base::Bind(&SendEventLogFileToRenderer, host,
+                     peer_connection_local_id));
+      ++number_active_log_files_;
+    }
+  }
+}
+
+void WebRTCEventLogHost::PeerConnectionRemoved(int peer_connection_local_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(active_peer_connection_local_id_.count(peer_connection_local_id) == 1);
+  active_peer_connection_local_id_.erase(peer_connection_local_id);
+}
+
+bool WebRTCEventLogHost::StartWebRTCEventLog(const base::FilePath& file_path) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (rtc_event_logging_enabled_)
+    return false;
+  RenderProcessHost* host = RenderProcessHost::FromID(render_process_id_);
+  if (host) {
+    rtc_event_logging_enabled_ = true;
+    base_file_path_ = file_path;
+    for (int local_id : active_peer_connection_local_id_) {
+      if (number_active_log_files_ < kMaxNumberLogFiles) {
+        BrowserThread::PostTaskAndReplyWithResult(
+            BrowserThread::FILE, FROM_HERE,
+            base::Bind(&CreateFileForProcess, file_path, render_process_id_,
+                       local_id),
+            base::Bind(&SendEventLogFileToRenderer, host, local_id));
+        ++number_active_log_files_;
+      }
+    }
+  }
+  return true;
+}
+
+bool WebRTCEventLogHost::StopWebRTCEventLog() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (!rtc_event_logging_enabled_)
+    return false;
+  rtc_event_logging_enabled_ = false;
+  number_active_log_files_ = 0;
+  RenderProcessHost* host = RenderProcessHost::FromID(render_process_id_);
+  if (host) {
+    for (int local_id : active_peer_connection_local_id_)
+      host->Send(new PeerConnectionTracker_StopEventLog(local_id));
+  }
+  return true;
+}
+
+}  // namespace content