Allow audio debug recordings through a private API extension.

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 "base/bind.h"
 #include "base/command_line.h"
@@ skipping 87 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(
+    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 16 matching lines @@
 void WebRtcLogBuffer::SetComplete() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!read_only_) << "Already set? (programmer error)";
   read_only_ = true;
   // Detach from the current thread so that we can check reads on a different
   // thread.  This is to make sure that Read()s still happen on one thread only.
   thread_checker_.DetachFromThread();
 }
 
 WebRtcLoggingHandlerHost::WebRtcLoggingHandlerHost(
-    Profile* profile, WebRtcLogUploader* log_uploader)
+    Profile* profile,
+    WebRtcLogUploader* log_uploader)
     : BrowserMessageFilter(WebRtcLoggingMsgStart),
       profile_(profile),
       logging_state_(CLOSED),
       upload_log_on_render_close_(false),
-      log_uploader_(log_uploader) {
+      log_uploader_(log_uploader),
+      is_audio_debug_recordings_in_progress_(false),
+      current_audio_debug_recordings_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 262 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 316 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,
+    base::FilePath log_directory) {

[tommi (sloooow) - chröme, 2015/12/18 19:54:04]

pass by const&?

[Guido Urdaneta, 2015/12/18 20:27:58]

Done.

+  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::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&WebRtcLoggingHandlerHost::DoStopAudioDebugRecordings, this,
+                 host, false /* no manual stop */,
+                 current_audio_debug_recordings_id_, callback, error_callback,
+                 prefix_path));
+}
+
+void WebRtcLoggingHandlerHost::DoStopAudioDebugRecordings(
+    content::RenderProcessHost* host,
+    bool is_manual_stop,
+    uint64_t audio_debug_recordings_id,
+    const AudioDebugRecordingsCallback& callback,
+    const AudioDebugRecordingsErrorCallback& error_callback,
+    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);
+}