Implements RTP header dumping.

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"
 #include "base/cpu.h"
 #include "base/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 "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/chrome_switches.h"
 #include "chrome/common/media/webrtc_logging_messages.h"
 #include "chrome/common/partial_circular_buffer.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/settings/cros_settings_names.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/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 base::IntToString;
 using content::BrowserThread;
 
+namespace {
 
 #if defined(OS_ANDROID)
 const size_t kWebRtcLogSize = 1 * 1024 * 1024;  // 1 MB
 #else
 const size_t kWebRtcLogSize = 6 * 1024 * 1024;  // 6 MB
 #endif
 
-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.
 std::string IPAddressToSensitiveString(const net::IPAddressNumber& address) {
 #if defined(NDEBUG)
@@ skipping 106 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
   if (logging_state_ != STOPPED) {
     if (!callback.is_null()) {
       content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
           base::Bind(callback, false, "", kLogNotStoppedOrNoLogOpen));
     }
     return;
   }
+  if (rtp_dump_handler_ && !rtp_dump_handler_->ReadyToRelease()) {
+    if (!callback.is_null()) {
+      content::BrowserThread::PostTask(
+          content::BrowserThread::UI,
+          FROM_HERE,
+          base::Bind(callback, false, "", "RTP dumping has not been stopped."));
+    }
+    return;
+  }
+
   upload_callback_ = callback;
   logging_state_ = UPLOADING;
   content::BrowserThread::PostTaskAndReplyWithResult(
       content::BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&WebRtcLoggingHandlerHost::GetLogDirectoryAndEnsureExists,
                  this),
-      base::Bind(&WebRtcLoggingHandlerHost::TriggerUploadLog, this));
+      base::Bind(&WebRtcLoggingHandlerHost::TriggerUpload, this));
 }
 
 void WebRtcLoggingHandlerHost::UploadLogDone() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   logging_state_ = CLOSED;
 }
 
 void WebRtcLoggingHandlerHost::DiscardLog(const GenericDoneCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
   GenericDoneCallback discard_callback = callback;
   if (logging_state_ != STOPPED) {
     FireGenericDoneCallback(&discard_callback, false,
                             kLogNotStoppedOrNoLogOpen);
     return;
   }
   g_browser_process->webrtc_log_uploader()->LoggingStoppedDontUpload();
   circular_buffer_.reset();
   log_buffer_.reset();
   logging_state_ = CLOSED;
+  rtp_dump_handler_.reset();
   FireGenericDoneCallback(&discard_callback, true, "");
 }
 
 void WebRtcLoggingHandlerHost::LogMessage(const std::string& message) {
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &WebRtcLoggingHandlerHost::AddLogMessageFromBrowser,
           this,
           WebRtcLoggingMessageData(base::Time::Now(), message)));
 }
 
 void WebRtcLoggingHandlerHost::StartRtpDump(
-    bool incoming,
-    bool outgoing,
-    const GenericDoneCallback& callback) {
-  NOTIMPLEMENTED();
+    RtpDumpType type,
+    const GenericDoneCallback& callback,
+    const content::RenderProcessHost::WebRtcStopRtpDumpCallback&
+        stop_callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  stop_rtp_dump_callback_ = stop_callback;

[vrk (LEFT CHROMIUM), 2014/05/28 23:55:07]

Add dcheck to make sure this is the same for incoming/outgoing.

+
+  if (!rtp_dump_handler_) {
+    content::BrowserThread::PostTaskAndReplyWithResult(
+        content::BrowserThread::FILE,
+        FROM_HERE,
+        base::Bind(&WebRtcLoggingHandlerHost::GetLogDirectoryAndEnsureExists,
+                   this),
+        base::Bind(&WebRtcLoggingHandlerHost::CreateRtpDumpHandlerAndStart,
+                   this,
+                   type,
+                   callback));
+    return;
+  }
+
+  GenericDoneCallback start_callback = callback;
+  DoStartRtpDump(type, &start_callback);
 }
 
 void WebRtcLoggingHandlerHost::StopRtpDump(
-    bool incoming,
-    bool outgoing,
+    RtpDumpType type,
     const GenericDoneCallback& callback) {
-  NOTIMPLEMENTED();
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(!callback.is_null());
+
+  if (!rtp_dump_handler_) {
+    GenericDoneCallback stop_callback = callback;
+    FireGenericDoneCallback(
+        &stop_callback, false, "RTP dump has not been started.");
+    return;
+  }
+
+  if (!stop_rtp_dump_callback_.is_null()) {
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(stop_rtp_dump_callback_,
+                   type == RTP_DUMP_INCOMING || type == RTP_DUMP_BOTH,
+                   type == RTP_DUMP_OUTGOING || type == RTP_DUMP_BOTH));
+  }
+
+  rtp_dump_handler_->StopDump(type, callback);
+}
+
+void WebRtcLoggingHandlerHost::OnRtpPacket(const uint8* packet_header,
+                                           size_t header_length,
+                                           size_t packet_length,
+                                           bool incoming) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  scoped_ptr<uint8[]> header_data(new uint8[header_length]);
+  memcpy(header_data.get(), packet_header, header_length);
+
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&WebRtcLoggingHandlerHost::DumpRtpPacketOnIOThread,
+                 this,
+                 base::Passed(&header_data),
+                 header_length,
+                 packet_length,
+                 incoming));
+}
+
+void WebRtcLoggingHandlerHost::DumpRtpPacketOnIOThread(
+    scoped_ptr<uint8[]> packet_header,
+    size_t header_length,
+    size_t packet_length,
+    bool incoming) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (rtp_dump_handler_) {

[vrk (LEFT CHROMIUM), 2014/05/28 23:55:07]

Add comment explaining when it is null.

+    rtp_dump_handler_->OnRtpPacket(
+        packet_header.get(), header_length, packet_length, incoming);
+  }
 }
 
 void WebRtcLoggingHandlerHost::OnChannelClosing() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (logging_state_ == STARTED || logging_state_ == STOPPED) {
     if (upload_log_on_render_close_) {
       logging_state_ = UPLOADING;
       logging_started_time_ = base::Time();
-      content::BrowserThread::PostTaskAndReplyWithResult(
-          content::BrowserThread::FILE,
-          FROM_HERE,
-          base::Bind(&WebRtcLoggingHandlerHost::GetLogDirectoryAndEnsureExists,
-                     this),
-          base::Bind(&WebRtcLoggingHandlerHost::TriggerUploadLog, this));
+
+      if (!rtp_dump_handler_) {
+        content::BrowserThread::PostTaskAndReplyWithResult(
+            content::BrowserThread::FILE,
+            FROM_HERE,
+            base::Bind(
+                &WebRtcLoggingHandlerHost::GetLogDirectoryAndEnsureExists,
+                this),
+            base::Bind(&WebRtcLoggingHandlerHost::TriggerUpload, this));
+      } else {
+        // The log directory has been ensured existing if |rtp_dump_handler_| is

[vrk (LEFT CHROMIUM), 2014/05/28 23:55:07]

nit: This is pretty subtle. I would just keep the code as it was with the
unnecessary thread hop for the rtp dump case. (The thread hop is possibly
unnecessary for the normal native log case too)

+        // not NULL.
+        rtp_dump_handler_->StopOngoingDumps(
+            base::Bind(&WebRtcLoggingHandlerHost::TriggerUpload,
+                       this,
+                       WebRtcLogList::GetWebRtcLogDirectoryForProfile(
+                           profile_->GetPath())));
+      }
     } else {
       g_browser_process->webrtc_log_uploader()->LoggingStoppedDontUpload();
     }
   }
   content::BrowserMessageFilter::OnChannelClosing();
 }
 
 void WebRtcLoggingHandlerHost::OnDestruct() const {
   BrowserThread::DeleteOnIOThread::Destruct(this);
 }
@@ skipping 181 matching lines @@
   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 WebRtcLoggingHandlerHost::TriggerUploadLog(
+void WebRtcLoggingHandlerHost::TriggerUpload(
     const base::FilePath& log_directory) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK_EQ(logging_state_, UPLOADING);
 
+  DoUploadLogAndDumps(log_directory,

[vrk (LEFT CHROMIUM), 2014/05/28 23:55:07]

Inline this method

+                      rtp_dump_handler_
+                          ? rtp_dump_handler_->ReleaseDumps()
+                          : WebRtcRtpDumpHandler::ReleasedDumps(
+                                base::FilePath(), base::FilePath()));
+}
+
+void WebRtcLoggingHandlerHost::FireGenericDoneCallback(
+    GenericDoneCallback* callback,
+    bool success,
+    const std::string& error_message) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(!(*callback).is_null());
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(*callback, success, error_message));
+  (*callback).Reset();
+}
+
+void WebRtcLoggingHandlerHost::CreateRtpDumpHandlerAndStart(
+    RtpDumpType type,
+    GenericDoneCallback callback,
+    const base::FilePath& dump_dir) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  // |rtp_dump_handler_| may be non-NULL if StartRtpDump is called again before
+  // GetLogDirectoryAndEnsureExists returns on the FILE thread for a previous
+  // StartRtpDump.
+  if (!rtp_dump_handler_)
+    rtp_dump_handler_.reset(new WebRtcRtpDumpHandler(dump_dir));
+
+  DoStartRtpDump(type, &callback);
+}
+
+void WebRtcLoggingHandlerHost::DoStartRtpDump(RtpDumpType type,
+                                              GenericDoneCallback* callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(rtp_dump_handler_);
+
+  std::string error;
+
+  bool result = rtp_dump_handler_->StartDump(type, &error);
+  FireGenericDoneCallback(callback, result, error);
+}
+
+void WebRtcLoggingHandlerHost::DoUploadLogAndDumps(
+    const base::FilePath& log_directory,
+    const WebRtcRtpDumpHandler::ReleasedDumps& rtp_dumps) {
   WebRtcLogUploadDoneData upload_done_data;
   upload_done_data.log_path = log_directory;
+
+  if (!rtp_dumps.incoming_dump_path.empty()) {
+    upload_done_data.rtp_dumps.push_back(
+        WebRtcRtpDumpDescription("rtpdump_recv", rtp_dumps.incoming_dump_path));

[vrk (LEFT CHROMIUM), 2014/05/28 23:55:07]

I think you should define these names in webrtc_log_uploader, see other
comments.

+  }
+
+  if (!rtp_dumps.outgoing_dump_path.empty()) {
+    upload_done_data.rtp_dumps.push_back(
+        WebRtcRtpDumpDescription("rtpdump_send", rtp_dumps.outgoing_dump_path));
+  }
+
   upload_done_data.callback = upload_callback_;
   upload_done_data.host = this;
   upload_callback_.Reset();
 
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, base::Bind(
       &WebRtcLogUploader::LoggingStoppedDoUpload,
       base::Unretained(g_browser_process->webrtc_log_uploader()),
       Passed(&log_buffer_),
       kWebRtcLogSize,
       meta_data_,
       upload_done_data));
 
   meta_data_.clear();
   circular_buffer_.reset();
 }
-
-void WebRtcLoggingHandlerHost::FireGenericDoneCallback(
-    GenericDoneCallback* callback, bool success,
-    const std::string& error_message) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(!(*callback).is_null());
-  content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
-                                   base::Bind(*callback, success,
-                                              error_message));
-  (*callback).Reset();
-}