Start and stop RTC event logs from private extension API.

chrome/browser/media/webrtc_internal_log_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_internal_log_handler_host.h"
+
+#include <string>
+#include <utility>
+
+#include "base/bind.h"
+#include "base/command_line.h"
+#include "base/cpu.h"
+#include "base/files/file_util.h"
+#include "base/logging.h"
+#include "base/prefs/pref_service.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/sys_info.h"
+#include "base/time/time.h"
+#include "build/build_config.h"
+#include "chrome/browser/bad_message.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/chromeos/settings/cros_settings.h"
+#include "chrome/browser/media/webrtc_log_list.h"
+#include "chrome/browser/media/webrtc_log_uploader.h"
+#include "chrome/browser/media/webrtc_rtp_dump_handler.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/common/channel_info.h"
+#include "chrome/common/chrome_switches.h"
+#include "chrome/common/media/webrtc_logging_messages.h"
+#include "chromeos/settings/cros_settings_names.h"
+#include "components/version_info/version_info.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/content_browser_client.h"
+#include "content/public/browser/gpu_data_manager.h"
+#include "content/public/browser/render_process_host.h"
+#include "gpu/config/gpu_info.h"
+#include "net/base/address_family.h"
+#include "net/base/ip_address_number.h"
+#include "net/base/net_util.h"
+#include "net/url_request/url_request_context_getter.h"
+
+#if defined(OS_LINUX)
+#include "base/linux_util.h"
+#endif
+
+#if defined(OS_MACOSX)
+#include "base/mac/mac_util.h"
+#endif
+
+#if defined(OS_CHROMEOS)
+#include "chromeos/system/statistics_provider.h"
+#endif
+
+using content::BrowserThread;
+
+namespace {
+
+// 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
+
+WebRtcInternalLogHandlerHost::WebRtcInternalLogHandlerHost(Profile* profile)
+    : BrowserMessageFilter(WebRtcLoggingMsgStart),
+      profile_(profile),
+      is_audio_debug_recordings_in_progress_(false),
+      current_audio_debug_recordings_id_(0),
+      is_rtc_event_logging_in_progress_(false),
+      current_rtc_event_log_id_(0) {
+  DCHECK(profile_);
+}
+
+WebRtcInternalLogHandlerHost::~WebRtcInternalLogHandlerHost() {
+  // TODO: Can we check that we dont hold any references to any Javascript
+  // callbacks?
+}
+
+void WebRtcInternalLogHandlerHost::StartAudioDebugRecordings(
+    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(&WebRtcInternalLogHandlerHost::GetLogDirectoryAndEnsureExists,
+                 this),
+      base::Bind(&WebRtcInternalLogHandlerHost::DoStartAudioDebugRecordings,
+                 this, host, delay, callback, error_callback));
+}
+
+void WebRtcInternalLogHandlerHost::StopAudioDebugRecordings(
+    content::RenderProcessHost* host,
+    const TimeLimitedRecordingCallback& callback,
+    const TimeLimitedRecordingErrorCallback& error_callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&WebRtcInternalLogHandlerHost::GetLogDirectoryAndEnsureExists,
+                 this),
+      base::Bind(&WebRtcInternalLogHandlerHost::DoStopAudioDebugRecordings,
+                 this, host, true /* manual stop */,
+                 current_audio_debug_recordings_id_, callback, error_callback));
+}
+
+void WebRtcInternalLogHandlerHost::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(&WebRtcInternalLogHandlerHost::GetLogDirectoryAndEnsureExists,
+                 this),
+      base::Bind(&WebRtcInternalLogHandlerHost::DoStartRtcEventLogging, this,
+                 host, delay, callback, error_callback));
+}
+
+void WebRtcInternalLogHandlerHost::StopRtcEventLogging(
+    content::RenderProcessHost* host,
+    const TimeLimitedRecordingCallback& callback,
+    const TimeLimitedRecordingErrorCallback& error_callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&WebRtcInternalLogHandlerHost::GetLogDirectoryAndEnsureExists,
+                 this),
+      base::Bind(&WebRtcInternalLogHandlerHost::DoStopRtcEventLogging, this,
+                 host, true /* manual stop */,
+                 current_audio_debug_recordings_id_, callback, error_callback));
+}
+
+void WebRtcInternalLogHandlerHost::OnChannelClosing() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  // We might want to check whether we have created any log and
+  // if so upload it.
+  content::BrowserMessageFilter::OnChannelClosing();
+}
+
+void WebRtcInternalLogHandlerHost::OnDestruct() const {
+  BrowserThread::DeleteOnIOThread::Destruct(this);
+}
+
+bool WebRtcInternalLogHandlerHost::OnMessageReceived(
+    const IPC::Message& message) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  bool handled = false;
+  return handled;
+}
+
+base::FilePath WebRtcInternalLogHandlerHost::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 WebRtcInternalLogHandlerHost::DoStartAudioDebugRecordings(
+    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_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(&WebRtcInternalLogHandlerHost::DoStopAudioDebugRecordings,
+                 this, host, false /* no manual stop */,
+                 current_audio_debug_recordings_id_, callback, error_callback,
+                 prefix_path),
+      delay);
+}
+
+void WebRtcInternalLogHandlerHost::DoStopAudioDebugRecordings(
+    content::RenderProcessHost* host,
+    bool is_manual_stop,
+    uint64_t audio_debug_recordings_id,
+    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 WebRtcInternalLogHandlerHost::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(&WebRtcInternalLogHandlerHost::DoStopRtcEventLogging, this,
+                 host, false /* no manual stop */, current_rtc_event_log_id_,
+                 callback, error_callback, prefix_path),
+      delay);
+}
+
+void WebRtcInternalLogHandlerHost::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);
+}