Start and stop RTC event logs from private extension API.

chrome/browser/media/webrtc_logging_handler_host.cc

 // Copyright 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 "chrome/browser/media/webrtc_logging_handler_host.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 98 matching lines @@
 
 // Returns a path name to be used as prefix for audio debug recordings files.
 base::FilePath GetAudioDebugRecordingsPrefixPath(
     const base::FilePath& directory,
     uint64_t audio_debug_recordings_id) {
   static const char kAudioDebugRecordingsFilePrefix[] = "AudioDebugRecordings.";
   return directory.AppendASCII(kAudioDebugRecordingsFilePrefix +
                                base::Int64ToString(audio_debug_recordings_id));
 }
 
+// Returns a path name to be used as prefix for RTC event log files.
+base::FilePath GetRtcEventLogPrefixPath(const base::FilePath& directory,
+                                        uint64_t rtc_event_log_id) {
+  static const char kRtcEventLogFilePrefix[] = "RtcEventLog.";
+  return directory.AppendASCII(kRtcEventLogFilePrefix +
+                               base::Int64ToString(rtc_event_log_id));
+}
+
 }  // namespace
 
 WebRtcLogBuffer::WebRtcLogBuffer()
     : buffer_(),
       circular_(&buffer_[0], sizeof(buffer_), sizeof(buffer_) / 2, false),
       read_only_(false) {
 }
 
 WebRtcLogBuffer::~WebRtcLogBuffer() {
   DCHECK(read_only_ || thread_checker_.CalledOnValidThread());
@@ skipping 24 matching lines @@
 
 WebRtcLoggingHandlerHost::WebRtcLoggingHandlerHost(
     Profile* profile,
     WebRtcLogUploader* log_uploader)
     : BrowserMessageFilter(WebRtcLoggingMsgStart),
       profile_(profile),
       logging_state_(CLOSED),
       upload_log_on_render_close_(false),
       log_uploader_(log_uploader),
       is_audio_debug_recordings_in_progress_(false),
-      current_audio_debug_recordings_id_(0) {
+      current_audio_debug_recordings_id_(0),
+      is_rtc_event_logging_in_progress_(false),
+      current_rtc_event_log_id_(0) {
   DCHECK(profile_);
   DCHECK(log_uploader_);
 }
 
 WebRtcLoggingHandlerHost::~WebRtcLoggingHandlerHost() {
   // If we hit this, then we might be leaking a log reference count (see
   // ApplyForStartLogging).
   DCHECK_EQ(CLOSED, logging_state_);
 }
 
@@ skipping 265 matching lines @@
   // create/ensure the log directory.
   if (rtp_dump_handler_) {
     rtp_dump_handler_->OnRtpPacket(
         packet_header.get(), header_length, packet_length, incoming);
   }
 }
 
 void WebRtcLoggingHandlerHost::StartAudioDebugRecordings(
     content::RenderProcessHost* host,
     base::TimeDelta delay,
-    const AudioDebugRecordingsCallback& callback,
-    const AudioDebugRecordingsErrorCallback& error_callback) {
+    const TimeLimitedRecordingCallback& callback,
+    const TimeLimitedRecordingErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&WebRtcLoggingHandlerHost::GetLogDirectoryAndEnsureExists,
                  this),
       base::Bind(&WebRtcLoggingHandlerHost::DoStartAudioDebugRecordings, this,
                  host, delay, callback, error_callback));
 }
 
 void WebRtcLoggingHandlerHost::StopAudioDebugRecordings(
     content::RenderProcessHost* host,
-    const AudioDebugRecordingsCallback& callback,
-    const AudioDebugRecordingsErrorCallback& error_callback) {
+    const TimeLimitedRecordingCallback& callback,
+    const TimeLimitedRecordingErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&WebRtcLoggingHandlerHost::GetLogDirectoryAndEnsureExists,
                  this),
       base::Bind(&WebRtcLoggingHandlerHost::DoStopAudioDebugRecordings, this,
                  host, true /* manual stop */,
                  current_audio_debug_recordings_id_, callback, error_callback));
 }
 
+void WebRtcLoggingHandlerHost::StartRtcEventLogging(
+    content::RenderProcessHost* host,
+    base::TimeDelta delay,
+    const TimeLimitedRecordingCallback& callback,
+    const TimeLimitedRecordingErrorCallback& error_callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&WebRtcLoggingHandlerHost::GetLogDirectoryAndEnsureExists,
+                 this),
+      base::Bind(&WebRtcLoggingHandlerHost::DoStartRtcEventLogging, this, host,
+                 delay, callback, error_callback));
+}
+
+void WebRtcLoggingHandlerHost::StopRtcEventLogging(
+    content::RenderProcessHost* host,
+    const TimeLimitedRecordingCallback& callback,
+    const TimeLimitedRecordingErrorCallback& error_callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&WebRtcLoggingHandlerHost::GetLogDirectoryAndEnsureExists,
+                 this),
+      base::Bind(&WebRtcLoggingHandlerHost::DoStopRtcEventLogging, this, host,
+                 true /* manual stop */, current_audio_debug_recordings_id_,
+                 callback, error_callback));
+}
+
 void WebRtcLoggingHandlerHost::OnChannelClosing() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (logging_state_ == STARTED || logging_state_ == STOPPED) {
     if (upload_log_on_render_close_) {
       logging_started_time_ = base::Time();
 
       content::BrowserThread::PostTaskAndReplyWithResult(
           content::BrowserThread::FILE,
           FROM_HERE,
           base::Bind(&WebRtcLoggingHandlerHost::GetLogDirectoryAndEnsureExists,
@@ skipping 320 matching lines @@
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(callback, success, error_message_with_state));
 }
 
 void WebRtcLoggingHandlerHost::DoStartAudioDebugRecordings(
     content::RenderProcessHost* host,
     base::TimeDelta delay,
-    const AudioDebugRecordingsCallback& callback,
-    const AudioDebugRecordingsErrorCallback& error_callback,
+    const TimeLimitedRecordingCallback& callback,
+    const TimeLimitedRecordingErrorCallback& error_callback,
     const base::FilePath& log_directory) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (is_audio_debug_recordings_in_progress_) {
     error_callback.Run("Audio debug recordings already in progress");
     return;
   }
 
   is_audio_debug_recordings_in_progress_ = true;
   base::FilePath prefix_path = GetAudioDebugRecordingsPrefixPath(
@@ skipping 12 matching lines @@
                  host, false /* no manual stop */,
                  current_audio_debug_recordings_id_, callback, error_callback,
                  prefix_path),
       delay);
 }
 
 void WebRtcLoggingHandlerHost::DoStopAudioDebugRecordings(
     content::RenderProcessHost* host,
     bool is_manual_stop,
     uint64_t audio_debug_recordings_id,
-    const AudioDebugRecordingsCallback& callback,
-    const AudioDebugRecordingsErrorCallback& error_callback,
+    const TimeLimitedRecordingCallback& callback,
+    const TimeLimitedRecordingErrorCallback& error_callback,
     const base::FilePath& log_directory) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_LE(audio_debug_recordings_id, current_audio_debug_recordings_id_);
 
   base::FilePath prefix_path = GetAudioDebugRecordingsPrefixPath(
       log_directory, audio_debug_recordings_id);
   // Prevent an old posted StopAudioDebugRecordings() 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 (audio_debug_recordings_id < current_audio_debug_recordings_id_) {
     callback.Run(prefix_path.AsUTF8Unsafe(), false /* not stopped */,
                  is_manual_stop);
     return;
   }
 
   if (!is_audio_debug_recordings_in_progress_) {
     error_callback.Run("No audio debug recording in progress");
     return;
   }
 
   host->DisableAudioDebugRecordings();
   is_audio_debug_recordings_in_progress_ = false;
   callback.Run(prefix_path.AsUTF8Unsafe(), true /* stopped */, is_manual_stop);
 }
+
+void WebRtcLoggingHandlerHost::DoStartRtcEventLogging(
+    content::RenderProcessHost* host,
+    base::TimeDelta delay,
+    const TimeLimitedRecordingCallback& callback,
+    const TimeLimitedRecordingErrorCallback& error_callback,
+    const base::FilePath& log_directory) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  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 =
+      GetRtcEventLogPrefixPath(log_directory, ++current_rtc_event_log_id_);
+  host->EnableEventLogRecordings(prefix_path);
+
+  if (delay.is_zero()) {
+    callback.Run(prefix_path.AsUTF8Unsafe(), false /* not stopped */,
+                 false /* not manually stopped */);
+    return;
+  }
+
+  BrowserThread::PostDelayedTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&WebRtcLoggingHandlerHost::DoStopRtcEventLogging, this, host,
+                 false /* no manual stop */, current_rtc_event_log_id_,
+                 callback, error_callback, prefix_path),
+      delay);
+}
+
+void WebRtcLoggingHandlerHost::DoStopRtcEventLogging(
+    content::RenderProcessHost* host,
+    bool is_manual_stop,
+    uint64_t rtc_event_log_id,
+    const TimeLimitedRecordingCallback& callback,
+    const TimeLimitedRecordingErrorCallback& error_callback,
+    const base::FilePath& log_directory) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK_LE(rtc_event_log_id, current_rtc_event_log_id_);
+
+  base::FilePath prefix_path =
+      GetRtcEventLogPrefixPath(log_directory, rtc_event_log_id);
+  // Prevent an old posted DoStopRtcEventLogging() 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_) {
+    callback.Run(prefix_path.AsUTF8Unsafe(), false /* not 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;
+  callback.Run(prefix_path.AsUTF8Unsafe(), true /* stopped */, is_manual_stop);
+}