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 113 matching lines @@
     }
     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();
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(!callback.is_null());
+
+  GenericDoneCallback start_callback = callback;
+  if (!incoming && !outgoing) {
+    FireGenericDoneCallback(&start_callback, false, "Invalid argument.");

[Henrik Grunell, 2014/05/14 12:14:12]

This will end up in the javascript app, I think that as much details as possible
is good for troubleshooting. What about "Either incoming or outgoing argument
must be set."

Thinking of this more, it would be best to have an enum {INCOMING, OUTGOING,
INCOMING_AND_OUTGOING}. Then this check isn't needed. Does the extension API
have two arguments? It should also be changed imo. Wdyt?

[jiayl, 2014/05/14 18:59:12]

Done improving the error message.

How could we change the extension API to pass an enum? Does that require
creating a new JS enum type? 

[Henrik Grunell, 2014/05/15 14:36:34]

I'd like a JS enum used in the JS API. We could do a follow-up for that and only
use an enum internally. Then convert in the extension API implementation and
check for both not false.

[jiayl, 2014/05/15 23:06:22]

Done.

+    return;
+  }
+
+  if (!rtp_dump_handler_) {
+    content::BrowserThread::PostTaskAndReplyWithResult(
+        content::BrowserThread::FILE,
+        FROM_HERE,
+        base::Bind(&WebRtcLoggingHandlerHost::GetLogDirectoryAndEnsureExists,
+                   this),
+        base::Bind(&WebRtcLoggingHandlerHost::CreateRtpDumpHandlerAndStart,
+                   this,
+                   incoming,
+                   outgoing,
+                   callback));
+    return;
+  }
+
+  DoStartRtpDump(incoming, outgoing, &start_callback);
 }
 
 void WebRtcLoggingHandlerHost::StopRtpDump(
     bool incoming,
     bool outgoing,
     const GenericDoneCallback& callback) {
-  NOTIMPLEMENTED();
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(!callback.is_null());
+
+  GenericDoneCallback stop_callback = callback;
+  if (!(incoming || outgoing) || !rtp_dump_handler_) {
+    FireGenericDoneCallback(&stop_callback, false, "Invalid argument");
+    return;
+  }
+
+  WebRtcRtpDumpHandler::PacketType type(incoming, outgoing);
+  rtp_dump_handler_->StopDump(type, callback);
+}
+
+void WebRtcLoggingHandlerHost::OnRtpPacket(const uint8* packet_header,
+                                           size_t header_length,
+                                           size_t packet_length,
+                                           bool incoming) {
+  // Can be called on any thread as it always posts to the IO thread.

[Henrik Grunell, 2014/05/14 12:14:12]

Move this comment to the declaration.

[jiayl, 2014/05/14 18:59:12]

Done.

+
+  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_) {
+    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));
+          base::Bind(&WebRtcLoggingHandlerHost::TriggerUpload, this));
     } 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);
 
+  WebRtcRtpDumpHandler::ReleasedDumps dumps;
+  if (rtp_dump_handler_) {

[Henrik Grunell, 2014/05/14 12:14:12]

Remove {}

[jiayl, 2014/05/14 18:59:12]

Done.

+    dumps = rtp_dump_handler_->ReleaseDumps();
+  }
+
+  DoUploadLogAndDumps(log_directory, dumps);
+}
+
+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(
+    bool incoming,
+    bool outgoing,
+    GenericDoneCallback callback,
+    const base::FilePath& dump_dir) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (!rtp_dump_handler_)
+    rtp_dump_handler_.reset(new WebRtcRtpDumpHandler(dump_dir));
+
+  DoStartRtpDump(incoming, outgoing, &callback);
+}
+
+void WebRtcLoggingHandlerHost::DoStartRtpDump(bool incoming,
+                                              bool outgoing,
+                                              GenericDoneCallback* callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(rtp_dump_handler_);
+
+  std::string error;
+  WebRtcRtpDumpHandler::PacketType type(incoming, outgoing);
+  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));
+  }
+
+  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();
-}