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 34 matching lines @@
 #include "base/mac/mac_util.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/system/statistics_provider.h"
 #endif
 
 using base::IntToString;
 using content::BrowserThread;
 
+// Key used to attach the handler to the RenderProcessHost.
+const char WebRtcLoggingHandlerHost::kWebRtcLoggingHandlerHostKey[] =
+    "kWebRtcLoggingHandlerHostKey";
+
 namespace {
 
 const char kLogNotStoppedOrNoLogOpen[] =
     "Logging not stopped or no log open.";
 
 // For privacy reasons when logging IP addresses. The returned "sensitive
 // string" is for release builds a string with the end stripped away. Last
 // octet for IPv4 and last 80 bits (5 groups) for IPv6. String will be
 // "1.2.3.x" and "1.2.3::" respectively. For debug builds, the string is
 // not stripped.
@@ skipping 31 matching lines @@
     const MetaDataMap& meta_data,
     std::string* message) {
   for (MetaDataMap::const_iterator it = meta_data.begin();
        it != meta_data.end(); ++it) {
     *message += it->first + ": " + it->second + '\n';
   }
   // Remove last '\n'.
   message->resize(message->size() - 1);
 }
 
-// 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));
-}
-
 }  // 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(
     int render_process_id,
     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),
       render_process_id_(render_process_id) {
   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 271 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // |rtp_dump_handler_| could be NULL if we are waiting for the FILE thread to
   // 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) {
-  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) {
-  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::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 343 matching lines @@
   case STOPPED:
     error_message_with_state += " State=stopped.";
     break;
   }
 
   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 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(
-      log_directory, ++current_audio_debug_recordings_id_);
-  host->EnableAudioDebugRecordings(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::DoStopAudioDebugRecordings, this,
-                 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 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);
-}