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"
@@ skipping 13 matching lines @@
 const char WebRtcEventLogHandler::kWebRtcEventLogHandlerKey[] =
     "kWebRtcEventLogHandlerKey";
 
 namespace {
 
 // 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) {
   static const char kWebRtcEventLogFilePrefix[] = "WebRtcEventLog.";
   return directory.AppendASCII(kWebRtcEventLogFilePrefix +
-                               base::Int64ToString(rtc_event_log_id));
+                               base::Uint64ToString(rtc_event_log_id));
 }
 
 }  // namespace
 
 WebRtcEventLogHandler::WebRtcEventLogHandler(Profile* profile)
     : profile_(profile),
-      is_rtc_event_logging_in_progress_(false),
       current_rtc_event_log_id_(0) {
   DCHECK(profile_);
   thread_checker_.DetachFromThread();
 }
 
 WebRtcEventLogHandler::~WebRtcEventLogHandler() {}
 
 void WebRtcEventLogHandler::StartWebRtcEventLogging(
     content::RenderProcessHost* host,
     base::TimeDelta delay,
@@ skipping 35 matching lines @@
 }
 
 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_) {
+  base::FilePath prefix_path =
+      GetWebRtcEventLogPrefixPath(log_directory, ++current_rtc_event_log_id_);
+  if (!host->StartWebRTCEventLog(prefix_path)) {
     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);
-
   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,
@@ skipping 18 matching lines @@
   // 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);
     return;
   }
 
-  if (!is_rtc_event_logging_in_progress_) {
+  if (!host->StopWebRTCEventLog()) {
     error_callback.Run("No RTC event logging in progress");
     return;
   }
 
-  host->DisableEventLogRecordings();
-  is_rtc_event_logging_in_progress_ = false;
   const bool is_stopped = true;
   callback.Run(prefix_path.AsUTF8Unsafe(), is_stopped, is_manual_stop);
 }