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..081ba15643af29abbcdb7a9b1d56688434378d14
--- /dev/null
+++ b/chrome/browser/media/webrtc_rtp_dump_handler.h
@@ -0,0 +1,125 @@
+// 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"
+
+namespace base {
+class FilePath;
+}  // namespace base
+
+class WebRtcRtpDumpWriter;
+
+// WebRtcRtpDumpHandler handles operations regarding the WebRTC RTP dump:
+// - Starts or stops the RTP dumping on behalf of the client.
+// - Stops the RTP dumping when the max dump file size is reached.
+// - Writes the dump file.
+// - Provides the dump file to the client code to be uploaded when
+//   ReleaseRtpDump is called.
+// - Cleans up the dump file if not transferred to the client before the object
+//   is destroyed.
+//
+// Must be created/used/destroyed on the IO thread.

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

I think you should have a ThreadChecker or make it a NonThreadSafe (which uses a
ThreadChecker).

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

It's a stronger requirement than NonThreadSafe or ThreadChecker. It has to be
run on 
the unique browser thread to avoid racing on the global dump count
(g_ongoing_rtp_dumps).

+class WebRtcRtpDumpHandler {
+ public:
+  typedef base::Callback<void(bool, const std::string&)> GenericDoneCallback;
+
+  struct PacketType {

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

Maybe an enum with three values instead since {false, false} isn't valid?

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

Done.

+    PacketType() : incoming(false), outgoing(false) {}
+    PacketType(bool incoming, bool outgoing)
+        : incoming(incoming), outgoing(outgoing) {}
+
+    bool incoming;
+    bool outgoing;
+  };
+
+  struct ReleasedDumps {
+    ReleasedDumps() {}
+
+    base::FilePath incoming_dump_path;
+    base::FilePath outgoing_dump_path;
+  };
+
+  // The caller must make sure |dump_dir| exists. RTP dump files are saved under
+  // |dump_dir| as "rtpdump_$DIRECTION_$TIMESTAMP.gz", where $DIRECTION is
+  // 'send' for outgoing dump or 'recv' for incoming dump. $TIMESTAMP is the
+  // dump started time converted to a double number in microsecond precision,
+  // which should guarantee the uniqueness across tabs and dump streams in
+  // practice.
+  explicit WebRtcRtpDumpHandler(const base::FilePath& dump_dir);
+  virtual ~WebRtcRtpDumpHandler();
+
+  // Starts the specified type of dumping. Incoming/outgoing dumping can be
+  // started separately. Returns true if called in a valid state, i.e.
+  // - if type.incoming == true, incoming dumping has not been started, and
+  //   outgoing dumping is not started or ongoing, returns true.
+  // - if type.outgoing == true, outgoing dumping has not been started, and
+  //   incoming dumping is not started or ongoing, returns true.
+  // - returns false in all other cases.
+  bool StartDump(const PacketType& type, std::string* error_message);
+
+  // Stops the specified type of dumping. Incoming/outgoing dumping can be
+  // stopped separately. Returns asynchronously through |callback|, where
+  // |success| is true if StopDump is called in a valid state.
+  void StopDump(const PacketType& type, const GenericDoneCallback& callback);
+
+  // Releases all the dumps to the caller and resets the state.
+  // It should only be called when both incoming and outgoing dumping has been
+  // stopped. Returns the dump file paths if called in a valid state.
+  //
+  // The caller will own the dump file after the method returns. If ReleaseDump
+  // returns false or not called before this object goes away, the dump file
+  // will be deleted by this object.
+  ReleasedDumps ReleaseDumps();
+
+  // Adds an RTP packet to the dump. The caller must make sure it's a valid RTP
+  // packet.
+  void OnRtpPacket(const uint8* packet_header,
+                   size_t header_length,
+                   size_t packet_length,
+                   bool incoming);
+
+ private:
+  friend class WebRtcRtpDumpHandlerTest;
+
+  // State transitions:
+  // initial --> STATE_NONE
+  // StartDump --> STATE_STARTED
+  // StopDump --> STATE_STOPPED
+  // ReleaseDump --> STATE_RELEASING
+  // ReleaseDump done --> STATE_NONE
+  enum State {
+    STATE_NONE,
+    STATE_STARTED,
+    STATE_STOPPING,
+    STATE_STOPPED,
+  };
+
+  // Callback from the dump writer when the max dump size is reached.
+  void OnMaxDumpSizeReached();
+
+  // Callback from the dump writer when ending a dump finishes. Calls the
+  // |callback| if all types of dump are ended.
+  void OnDumpEnded(const GenericDoneCallback& callback,
+                   bool incoming,
+                   bool succeeded);
+
+  // For mocking the dump writer in unit tests.
+  void SetDumpWriterForTesting(scoped_ptr<WebRtcRtpDumpWriter> writer);

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

Can the writer be injected in the constructor instead?

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

It cannot. Because the writer has to be created with the max size callback bound
to the handler. So the handler must be created before the writer is created.

+
+  const base::FilePath dump_dir_;

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

Comment all member variables.

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

Done.

+  base::FilePath incoming_dump_path_;
+  base::FilePath outgoing_dump_path_;
+  State incoming_state_;
+  State outgoing_state_;
+  scoped_ptr<WebRtcRtpDumpWriter> dump_writer_;

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

So there's one writer that for both incoming and outgoing. It seems that
incoming and outgoing can be handled completely separately, maybe there can be
two dump handlers, one for incoming and one for outgoing? We'll get rid of all
incoming_* and outgoing_*. Could they have a dump writer each? Or is it tightly
coupled together? Maybe share an injected writer? Lifetime must be ensured in
that case.

[jiayl, 2014/05/14 16:07:58]

It'll be more difficult to apply the max dump limit if the writers are
separated, because
the limit is on the total size of all dumps.

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

I see. And the incoming and outgoing can't be expected to be ~equal. OK, let's
keep it this way.

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