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

chrome/browser/media/webrtc_event_log_handler.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 "chrome/browser/media/webrtc_event_log_handler.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/media/webrtc_log_list.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
+#include "content/common/media/peer_connection_tracker_messages.h"

[ncarter (slow), 2016/05/18 21:49:56]

As general a rule, IPC messages are not part of the content public API. This
means that if an IPC is sent by content/renderer, it should be handled by
content/browser, and not by e.g. chrome/ -- and vice versa.

Perhaps, if you need to send the IPC message from the chrome/ layer, they should
be declared in  chrome/common/media/webrtc_logging_messages.h , instead of
content/?

[Henrik Grunell, 2016/05/19 14:10:41]

Ah, good point. The IPC should be done over content. If done in Chrome we need
to add another point of interface between content and the embedder in the
renderer, which is unfortunate.

[Ivo-OOO until feb 6, 2016/05/20 14:58:48]

I moved the IPC sending code into content/, in a new class called
WebRTCEventLogHost, which is a member of RenderProcessHostImpl.

 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
+#include "ipc/ipc_platform_file.h"
 
 using content::BrowserThread;
 
 // Keys used to attach handler to the RenderProcessHost
 const char WebRtcEventLogHandler::kWebRtcEventLogHandlerKey[] =
     "kWebRtcEventLogHandlerKey";
 
 namespace {
 
+#if defined(OS_ANDROID)
+const int kMaxNumberLogFiles = 3;
+#else
+const int kMaxNumberLogFiles = 10;
+#endif
+
 // Returns a path name to be used as prefix for RTC event log files.
-base::FilePath GetWebRtcEventLogPrefixPath(const base::FilePath& directory,
-                                           uint64_t rtc_event_log_id) {
+base::FilePath GetWebRtcEventLogPrefixPath(const base::FilePath& directory) {
   static const char kWebRtcEventLogFilePrefix[] = "WebRtcEventLog.";
-  return directory.AppendASCII(kWebRtcEventLogFilePrefix +
-                               base::Int64ToString(rtc_event_log_id));
+  return directory.AppendASCII(kWebRtcEventLogFilePrefix);
 }
 
+// Appends the IDs to the RTC event log file name.
+base::FilePath GetWebRtcEventLogPath(const base::FilePath& base_file,
+                                     int render_process_id,
+                                     uint64_t rtc_event_log_id) {
+  return base_file.AddExtension(base::IntToString(render_process_id))
+      .AddExtension(base::Uint64ToString(rtc_event_log_id));
+}
+
+// Opens a logfile to pass on to the renderer.
+IPC::PlatformFileForTransit CreateFileForProcess(
+    const base::FilePath& base_path,
+    int render_process_id,
+    uint64_t rtc_event_log_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::FilePath file_path =
+      GetWebRtcEventLogPath(base_path, render_process_id, rtc_event_log_id);
+  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 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
 
-WebRtcEventLogHandler::WebRtcEventLogHandler(Profile* profile)
-    : profile_(profile),
+WebRtcEventLogHandler::WebRtcEventLogHandler(int process_id, Profile* profile)
+    : render_process_id(process_id),
+      profile_(profile),
       is_rtc_event_logging_in_progress_(false),
+      number_active_log_files_(0),
       current_rtc_event_log_id_(0) {
   DCHECK(profile_);
   thread_checker_.DetachFromThread();
+  content::RenderProcessHost* host =
+      content::RenderProcessHost::FromID(process_id);
+  using StartEventLogFn =
+      void (WebRtcEventLogHandler::*)(const base::FilePath& file_path);
+  using StopEventLogFn = void (WebRtcEventLogHandler::*)();
+  StartEventLogFn start_fn = &WebRtcEventLogHandler::StartWebRtcEventLogging;
+  StopEventLogFn stop_fn = &WebRtcEventLogHandler::StopWebRtcEventLogging;
+  if (host) {
+    host->RegisterEventLogHandler(base::Bind(start_fn, this),
+                                  base::Bind(stop_fn, this));
+    host->RegisterPeerConnectionCallbacks(
+        base::Bind(&WebRtcEventLogHandler::OnPeerConnectionAdded, this),
+        base::Bind(&WebRtcEventLogHandler::OnPeerConnectionRemoved, this));
+  }
 }
 
 WebRtcEventLogHandler::~WebRtcEventLogHandler() {}
 
 void WebRtcEventLogHandler::StartWebRtcEventLogging(
     content::RenderProcessHost* host,
     base::TimeDelta delay,
     const RecordingDoneCallback& callback,
     const RecordingErrorCallback& error_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&WebRtcEventLogHandler::GetLogDirectoryAndEnsureExists, this),
       base::Bind(&WebRtcEventLogHandler::DoStartWebRtcEventLogging, this, host,
                  delay, callback, error_callback));
 }
 
+void WebRtcEventLogHandler::StartWebRtcEventLogging(
+    const base::FilePath& file_path) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  content::RenderProcessHost* host =
+      content::RenderProcessHost::FromID(render_process_id);
+  if (host) {
+    is_rtc_event_logging_in_progress_ = true;
+    base_file_path_ = file_path;
+    number_active_log_files_ = 0;
+    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_++;
+      }
+    }
+  }
+}
+
 void WebRtcEventLogHandler::StopWebRtcEventLogging(
     content::RenderProcessHost* host,
     const RecordingDoneCallback& callback,
     const RecordingErrorCallback& error_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const bool is_manual_stop = true;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&WebRtcEventLogHandler::GetLogDirectoryAndEnsureExists, this),
       base::Bind(&WebRtcEventLogHandler::DoStopWebRtcEventLogging, this, host,
                  is_manual_stop, current_rtc_event_log_id_, callback,
                  error_callback));
 }
 
+void WebRtcEventLogHandler::StopWebRtcEventLogging() {
+  is_rtc_event_logging_in_progress_ = false;
+  content::RenderProcessHost* host =
+      content::RenderProcessHost::FromID(render_process_id);
+  if (host) {
+    for (int local_id : active_peer_connection_local_id_) {
+      host->Send(new PeerConnectionTracker_StopEventLog(local_id));
+    }
+  }
+}
+
+void WebRtcEventLogHandler::OnPeerConnectionAdded(int connection_id) {
+  active_peer_connection_local_id_.insert(connection_id);
+  if (is_rtc_event_logging_in_progress_ &&
+      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,
+                     connection_id),
+          base::Bind(&SendEventLogFileToRenderer, host, connection_id));
+      number_active_log_files_++;
+    }
+  }
+}
+
+void WebRtcEventLogHandler::OnPeerConnectionRemoved(int connection_id) {
+  active_peer_connection_local_id_.erase(connection_id);
+}
+
 base::FilePath WebRtcEventLogHandler::GetLogDirectoryAndEnsureExists() {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   base::FilePath log_dir_path =
       WebRtcLogList::GetWebRtcLogDirectoryForProfile(profile_->GetPath());
   base::File::Error error;
   if (!base::CreateDirectoryAndGetError(log_dir_path, &error)) {
     DLOG(ERROR) << "Could not create WebRTC log directory, error: " << error;
     return base::FilePath();
   }
   return log_dir_path;
 }
 
 void WebRtcEventLogHandler::DoStartWebRtcEventLogging(
     content::RenderProcessHost* host,
     base::TimeDelta delay,
     const RecordingDoneCallback& callback,
     const RecordingErrorCallback& error_callback,
     const base::FilePath& log_directory) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (is_rtc_event_logging_in_progress_) {
     error_callback.Run("RTC event logging already in progress");
     return;
   }
-
-  is_rtc_event_logging_in_progress_ = true;
-  base::FilePath prefix_path =
-      GetWebRtcEventLogPrefixPath(log_directory, ++current_rtc_event_log_id_);
-  host->EnableEventLogRecordings(prefix_path);
+  base::FilePath prefix_path = GetWebRtcEventLogPrefixPath(log_directory);
+  StartWebRtcEventLogging(prefix_path);
 
   if (delay.is_zero()) {
     const bool is_stopped = false, is_manual_stop = false;
     callback.Run(prefix_path.AsUTF8Unsafe(), is_stopped, is_manual_stop);
     return;
   }
 
   const bool is_manual_stop = false;
   BrowserThread::PostDelayedTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&WebRtcEventLogHandler::DoStopWebRtcEventLogging, this, host,
                  is_manual_stop, current_rtc_event_log_id_, callback,
                  error_callback, log_directory),
       delay);
 }
 
 void WebRtcEventLogHandler::DoStopWebRtcEventLogging(
     content::RenderProcessHost* host,
     bool is_manual_stop,
     uint64_t rtc_event_log_id,
     const RecordingDoneCallback& callback,
     const RecordingErrorCallback& error_callback,
     const base::FilePath& log_directory) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_LE(rtc_event_log_id, current_rtc_event_log_id_);
 
-  base::FilePath prefix_path =
-      GetWebRtcEventLogPrefixPath(log_directory, rtc_event_log_id);
+  base::FilePath prefix_path = GetWebRtcEventLogPrefixPath(log_directory);
+  base::FilePath file_path =
+      GetWebRtcEventLogPath(prefix_path, host->GetID(), rtc_event_log_id);
   // Prevent an old posted DoStopWebRtcEventLogging() call to stop a newer dump.
   // This could happen in a sequence like:
   //   Start(10);  // Start dump 1. Post Stop() to run after 10 seconds.
   //   Stop();     // Manually stop dump 1 before 10 seconds;
   //   Start(20);  // Start dump 2. Posted Stop() for 1 should not stop dump 2.
   if (rtc_event_log_id < current_rtc_event_log_id_) {
     const bool is_stopped = false;
-    callback.Run(prefix_path.AsUTF8Unsafe(), is_stopped, is_manual_stop);
+    callback.Run(file_path.AsUTF8Unsafe(), is_stopped, is_manual_stop);
     return;
   }
 
   if (!is_rtc_event_logging_in_progress_) {
     error_callback.Run("No RTC event logging in progress");
     return;
   }
 
-  host->DisableEventLogRecordings();
-  is_rtc_event_logging_in_progress_ = false;
+  StopWebRtcEventLogging();
   const bool is_stopped = true;
-  callback.Run(prefix_path.AsUTF8Unsafe(), is_stopped, is_manual_stop);
+  callback.Run(file_path.AsUTF8Unsafe(), is_stopped, is_manual_stop);
 }