Implements RTP header dumping.

chrome/browser/media/webrtc_rtp_dump_handler.cc

Index: chrome/browser/media/webrtc_rtp_dump_handler.cc
diff --git a/chrome/browser/media/webrtc_rtp_dump_handler.cc b/chrome/browser/media/webrtc_rtp_dump_handler.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e2377fcdc83250a023e339c7ea0787ae5dbb4f23
--- /dev/null
+++ b/chrome/browser/media/webrtc_rtp_dump_handler.cc
@@ -0,0 +1,213 @@
+// Copyright 2014 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_rtp_dump_handler.h"
+
+#include "base/file_util.h"
+#include "base/logging.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/time/time.h"
+#include "chrome/browser/media/webrtc_rtp_dump_writer.h"
+#include "content/public/browser/browser_thread.h"
+
+using content::BrowserThread;
+
+namespace {
+
+// |path| must be a copy of FilePath, not a reference.
+void DeleteFileHelper(base::FilePath path) {
+  base::DeleteFile(path, false);
+}
+
+static const size_t kMaxOngoingRtpDumpsAllowed = 5;
+
+// The browser process wide total number of ongoing (i.e. started and not
+// released) RTP dumps. Incoming and outgoing in one WebRtcDumpHandler are
+// counted as one dump.
+// Must be accessed on the browser IO thread.
+static size_t g_ongoing_rtp_dumps = 0;
+
+}  // namespace
+
+WebRtcRtpDumpHandler::WebRtcRtpDumpHandler(const base::FilePath& dump_dir)
+    : dump_dir_(dump_dir),
+      incoming_state_(STATE_NONE),
+      outgoing_state_(STATE_NONE) {
+}
+
+WebRtcRtpDumpHandler::~WebRtcRtpDumpHandler() {
+  if (!incoming_dump_path_.empty()) {
+    BrowserThread::PostTask(BrowserThread::FILE,
+                            FROM_HERE,
+                            base::Bind(&DeleteFileHelper, incoming_dump_path_));
+  }
+
+  if (!outgoing_dump_path_.empty()) {
+    BrowserThread::PostTask(BrowserThread::FILE,
+                            FROM_HERE,
+                            base::Bind(&DeleteFileHelper, outgoing_dump_path_));
+  }
+
+  if (dump_writer_)
+    g_ongoing_rtp_dumps--;
+}
+
+bool WebRtcRtpDumpHandler::StartDump(const PacketType& type) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  bool succeeded = false;
+
+  if (type.incoming && incoming_state_ == STATE_NONE &&
+      outgoing_state_ <= STATE_STARTED) {
+    incoming_state_ = STATE_STARTED;
+    succeeded = true;
+  }
+  if (type.outgoing && outgoing_state_ == STATE_NONE &&
+      incoming_state_ <= STATE_STARTED) {
+    outgoing_state_ = STATE_STARTED;
+    succeeded = true;
+  }
+
+  if (!dump_writer_ && g_ongoing_rtp_dumps >= kMaxOngoingRtpDumpsAllowed) {
+    DVLOG(2) << "Max RTP dump limit reached.";
+    return false;
+  }
+
+  DVLOG(2) << "Start RTP dumping: incoming = " << type.incoming
+           << ", outgoing = " << type.outgoing;
+
+  if (succeeded && !dump_writer_) {
+    g_ongoing_rtp_dumps++;
+
+    static const char kRecvDumpFilePrefix[] = "rtpdump_recv_";
+    static const char kSendDumpFilePrefix[] = "rtpdump_send_";
+    static const char kDumpFileExtension[] = ".gz";
+    static const size_t kMaxDumpSize = 5 * 1024 * 1024;  // 5MB
+
+    std::string dump_id = base::DoubleToString(base::Time::Now().ToDoubleT());
+    incoming_dump_path_ =
+        dump_dir_.AppendASCII(std::string(kRecvDumpFilePrefix) + dump_id)
+            .AddExtension(FILE_PATH_LITERAL(kDumpFileExtension));
+
+    outgoing_dump_path_ =
+        dump_dir_.AppendASCII(std::string(kSendDumpFilePrefix) + dump_id)
+            .AddExtension(FILE_PATH_LITERAL(kDumpFileExtension));
+
+    // WebRtcRtpDumpWriter does not support changing the dump path after it's
+    // created. So we assign both incoming and outgoing dump path even if only
+    // one type of dumping has been started.
+    dump_writer_.reset(new WebRtcRtpDumpWriter(
+        incoming_dump_path_,
+        outgoing_dump_path_,
+        kMaxDumpSize,
+        base::Bind(&WebRtcRtpDumpHandler::OnMaxDumpSizeReached,
+                   base::Unretained(this))));
+  }
+  return succeeded;
+}
+
+bool WebRtcRtpDumpHandler::StopDump(const PacketType& type) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  bool succeeded = false;
+  if (type.incoming && incoming_state_ == STATE_STARTED) {
+    incoming_state_ = STATE_STOPPED;
+    succeeded = true;
+  }
+  if (type.outgoing && outgoing_state_ == STATE_STARTED) {
+    outgoing_state_ = STATE_STOPPED;
+    succeeded = true;
+  }
+
+  DVLOG(2) << "Stop RTP dumping: incoming = " << type.incoming
+           << ", outgoing = " << type.outgoing;
+  return succeeded;
+}
+
+bool WebRtcRtpDumpHandler::ReleaseDump(const ReleaseDumpCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  // All types of dumps must have been stopped or not started.
+  if (incoming_state_ == STATE_STARTED || incoming_state_ == STATE_RELEASING ||
+      outgoing_state_ == STATE_STARTED || outgoing_state_ == STATE_RELEASING ||
+      (incoming_state_ == STATE_NONE && outgoing_state_ == STATE_NONE) ||
+      !dump_writer_)
+    return false;
+
+  if (incoming_state_ == STATE_STOPPED)
+    incoming_state_ = STATE_RELEASING;
+
+  if (outgoing_state_ == STATE_STOPPED)
+    outgoing_state_ = STATE_RELEASING;
+
+  dump_writer_->EndDump(base::Bind(
+      &WebRtcRtpDumpHandler::OnDumpEnded, base::Unretained(this), callback));
+
+  DVLOG(2) << "Releasing RTP dump.";
+
+  return true;
+}
+
+void WebRtcRtpDumpHandler::OnRtpPacket(const uint8* packet_header,
+                                       size_t header_length,
+                                       size_t packet_length,
+                                       bool incoming) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if ((incoming && incoming_state_ != STATE_STARTED) ||
+      (!incoming && outgoing_state_ != STATE_STARTED))
+    return;
+
+  dump_writer_->WriteRtpPacket(
+      packet_header, header_length, packet_length, incoming);
+}
+
+void WebRtcRtpDumpHandler::SetDumpWriterForTesting(
+    scoped_ptr<WebRtcRtpDumpWriter> writer) {
+  DCHECK(!dump_writer_.get());
+  dump_writer_ = writer.Pass();
+  g_ongoing_rtp_dumps++;
+}
+
+void WebRtcRtpDumpHandler::OnMaxDumpSizeReached() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  PacketType type = {true, true};
+  StopDump(type);
+}
+
+void WebRtcRtpDumpHandler::OnDumpEnded(const ReleaseDumpCallback& callback,
+                                       bool succeeded) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  dump_writer_.reset();
+  g_ongoing_rtp_dumps--;
+
+  ReleasedDumps dumps;
+  if (succeeded) {
+    dumps.incoming_dump_path = incoming_dump_path_;
+    dumps.outgoing_dump_path = outgoing_dump_path_;
+    callback.Run(dumps);
+
+    DVLOG(2) << "RTP dump released: " << incoming_dump_path_.value() << ", "
+             << outgoing_dump_path_.value();
+  } else {
+    BrowserThread::PostTask(BrowserThread::FILE,
+                            FROM_HERE,
+                            base::Bind(&DeleteFileHelper, incoming_dump_path_));
+
+    BrowserThread::PostTask(BrowserThread::FILE,
+                            FROM_HERE,
+                            base::Bind(&DeleteFileHelper, outgoing_dump_path_));
+
+    // Call back with an empty list.
+    callback.Run(dumps);
+    DVLOG(2) << "Releasing RTP dump failed.";
+  }
+
+  incoming_state_ = STATE_NONE;
+  outgoing_state_ = STATE_NONE;
+  incoming_dump_path_.clear();
+  outgoing_dump_path_.clear();
+}