Implements RTP header dumping.

chrome/browser/media/webrtc_rtp_dump_handler.h

Index: chrome/browser/media/webrtc_rtp_dump_handler.h
diff --git a/chrome/browser/media/webrtc_rtp_dump_handler.h b/chrome/browser/media/webrtc_rtp_dump_handler.h
new file mode 100644
index 0000000000000000000000000000000000000000..b40621d1706ea43bdbe8d08038c1e50bd78f63d6
--- /dev/null
+++ b/chrome/browser/media/webrtc_rtp_dump_handler.h
@@ -0,0 +1,87 @@
+// 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.
+
+#ifndef CHROME_BROWSER_MEDIA_WEBRTC_RTP_DUMP_HANDLER_H_
+#define CHROME_BROWSER_MEDIA_WEBRTC_RTP_DUMP_HANDLER_H_
+
+#include "base/basictypes.h"
+#include "base/callback.h"
+#include "base/files/file_path.h"
+#include "third_party/libjingle/source/talk/base/stream.h"
+#include "third_party/libjingle/source/talk/media/base/rtpdump.h"
+
+// An interface for tracking RTP packets.
+class WebRtcRtpPacketObserver {
+ public:
+  virtual void OnIncomingRtpPacket(const uint8* packet, size_t length) = 0;
+  virtual void OnOutgoingRtpPacket(const uint8* packet, size_t length) = 0;
+};
+
+// WebRtcRtpDumpHandler handles operations regarding the WebRTC RTP dump:
+// - Adds the RTP headers to an in-memory buffer.
+// - When the in-memory buffer is full, compresses it, and writes it to the
+//   disk.
+// - Provides the dump file to the client code to be uploaded when
+//   ReleaseRtpDump is called.
+// All public methods should be called on the IO thread.
+class WebRtcRtpDumpHandler : public WebRtcRtpPacketObserver {
+ public:
+  struct PacketType {
+    bool incoming;
+    bool outgoing;
+  };
+
+  typedef base::Callback<void(bool success, const base::FilePath& dump_file)>
+      ReleaseDumpCallback;
+
+  // The caller must make sure |dump_dir| exists. RTP dump files are saved under
+  // |dump_dir| as "rtpdump_XXXXX.gz".
+  explicit WebRtcRtpDumpHandler(const base::FilePath& dump_dir);
+  virtual ~WebRtcRtpDumpHandler();
+
+  // Incoming/outgoing dumping can be started separately. Returns true if called
+  // in a valid state, i.e. dumping has not been started for any type specified
+  // in |type|.
+  bool StartDump(const PacketType& type);
+
+  // Incoming/outgoing dumping can be stopped separately. Returns true if called
+  // in a valid state, i.e. dumping has been started and not stopped for any
+  // type specified in |type|.
+  bool StopDump(const PacketType& type);
+
+  // It should only be called when both incoming and outgoing dumping has been
+  // stopped. Returns true if it's called in a valid state and the callback will
+  // be called when it finishes writing the dump file.
+  // If the method returns true, the caller will own the dump file and should
+  // clean it up from the disk when suitable. Otherwise, the dump will be
+  // deleted before WebRtcRtpDumpHandler goes away.
+  bool ReleaseDump(const ReleaseDumpCallback& callback);
+
+  // Implementation of WebRtcRtpPacketObserver.
+  virtual void OnIncomingRtpPacket(const uint8* packet, size_t length) OVERRIDE;

[Henrik Grunell, 2014/05/05 14:38:03]

Who will call these?

[jiayl, 2014/05/05 16:50:56]

From the socket classes in content/browser/renderer_host/p2p

[Henrik Grunell, 2014/05/06 08:34:26]

Through RenderProcessHostImpl as for the log messages and as I saw now that you
wrote this in the description?

+  virtual void OnOutgoingRtpPacket(const uint8* packet, size_t length) OVERRIDE;
+
+ private:
+  // State transitions:
+  // initial --> STATE_NONE
+  // StartDump --> STATE_STARTED
+  // StopDump --> STATE_STOPPED
+  // ReleaseDump --> STATE_NONE
+  enum State {
+    STATE_NONE,
+    STATE_STARTED,
+    STATE_STOPPED
+  };
+
+  base::FilePath dump_dir_;
+  base::FilePath dump_path_;
+  State incoming_state_;
+  State outgoing_state_;
+  scoped_ptr<talk_base::FifoBuffer> dump_buffer_;

[Henrik Grunell, 2014/05/05 14:38:03]

Does it have to be a talk_base::FifoBuffer?

[jiayl, 2014/05/05 16:50:56]

MemoryBufferBase is enough for the use, but it doesn't have a public ctor, so
I'll need to change Libjingle. I can certainly make the change.

+  scoped_ptr<cricket::RtpDumpWriter> dump_writer_;

[Henrik Grunell, 2014/05/05 14:38:03]

I'm wondering about how large the data can be? We should limit it (also if we
write it to disk), and doing that, should we use a circular buffer? If it's not
expected to be too large, we could just keep it in memory and write it to disk
in the uploader.

[jiayl, 2014/05/05 16:50:56]

For 2Mbps video, there are 250 packets/s; for 40kbps audio, there are 50
packets/s. So if each RTP header is 12 bytes uncompressed, it will be 12 * 300 =
3600 bytes/s for just one audio+video stream. If there are multiple steams, say
10, it can go over 1 MB within a minute.
So I think it's too large to hold all in memory, even compressed assuming a 10:1
compression rate. 
Limiting the on-disk file size makes sense of course. 

+
+  DISALLOW_COPY_AND_ASSIGN(WebRtcRtpDumpHandler);
+};
+
+#endif  // CHROME_BROWSER_MEDIA_WEBRTC_RTP_DUMP_HANDLER_H_