1// Copyright 2014 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef CHROME_BROWSER_MEDIA_WEBRTC_RTP_DUMP_WRITER_H_
6#define CHROME_BROWSER_MEDIA_WEBRTC_RTP_DUMP_WRITER_H_
7
8#include "base/basictypes.h"
9#include "base/callback.h"
10#include "base/files/file_path.h"
11#include "base/memory/weak_ptr.h"
12#include "base/threading/thread_checker.h"
13#include "base/time/time.h"
14#include "chrome/browser/media/rtp_dump_type.h"
15
16// This class is responsible for creating the compressed RTP header dump file:
17// - Adds the RTP headers to an in-memory buffer.
18// - When the in-memory buffer is full, compresses it, and writes it to the
19//   disk.
20// - Notifies the caller when the on-disk file size reaches the max limit.
21// - The uncompressed dump follows the standard RTPPlay format
22//   (http://www.cs.columbia.edu/irt/software/rtptools/).
23// - The caller is always responsible for cleaning up the dump file in all
24//   cases.
25// - WebRtcRtpDumpWriter does not stop writing to the dump after the max size
26//   limit is reached. The caller must stop calling WriteRtpPacket instead.
27//
28// This object must run on the IO thread.
29class WebRtcRtpDumpWriter {
30 public:
31  typedef base::Callback<void(bool incoming_succeeded, bool outgoing_succeeded)>
32      EndDumpCallback;
33
34  // |incoming_dump_path| and |outgoing_dump_path| are the file paths of the
35  // compressed dump files for incoming and outgoing packets respectively.
36  // |max_dump_size| is the max size of the compressed dump file in bytes.
37  // |max_dump_size_reached_callback| will be called when the on-disk file size
38  // reaches |max_dump_size|.
39  WebRtcRtpDumpWriter(const base::FilePath& incoming_dump_path,
40                      const base::FilePath& outgoing_dump_path,
41                      size_t max_dump_size,
42                      const base::Closure& max_dump_size_reached_callback);
43
44  virtual ~WebRtcRtpDumpWriter();
45
46  // Adds a RTP packet to the dump. The caller must make sure it's a valid RTP
47  // packet. No validation is done by this method.
48  virtual void WriteRtpPacket(const uint8* packet_header,
49                              size_t header_length,
50                              size_t packet_length,
51                              bool incoming);
52
53  // Flushes the in-memory buffer to the disk and ends the dump. The caller must
54  // make sure the dump has not already been ended.
55  // |finished_callback| will be called to indicate whether the dump is valid.
56  // If this object is destroyed before the operation is finished, the callback
57  // will be canceled and the dump files will be deleted.
58  virtual void EndDump(RtpDumpType type,
59                       const EndDumpCallback& finished_callback);
60
61  size_t max_dump_size() const;
62
63 private:
64  enum FlushResult {
65    // Flushing has succeeded and the dump size is under the max limit.
66    FLUSH_RESULT_SUCCESS,
67    // Nothing has been written to disk and the dump is empty.
68    FLUSH_RESULT_NO_DATA,
69    // Flushing has failed for other reasons.
70    FLUSH_RESULT_FAILURE
71  };
72
73  class FileThreadWorker;
74
75  typedef base::Callback<void(bool)> FlushDoneCallback;
76
77  // Used by EndDump to cache the input and intermediate results.
78  struct EndDumpContext {
79    EndDumpContext(RtpDumpType type, const EndDumpCallback& callback);
80    ~EndDumpContext();
81
82    RtpDumpType type;
83    bool incoming_succeeded;
84    bool outgoing_succeeded;
85    EndDumpCallback callback;
86  };
87
88  // Flushes the in-memory buffer to disk. If |incoming| is true, the incoming
89  // buffer will be flushed; otherwise, the outgoing buffer will be flushed.
90  // The dump file will be ended if |end_stream| is true. |callback| will be
91  // called when flushing is done.
92  void FlushBuffer(bool incoming,
93                   bool end_stream,
94                   const FlushDoneCallback& callback);
95
96  // Called when FlushBuffer finishes. Checks the max dump size limit and
97  // maybe calls the |max_dump_size_reached_callback_|. Also calls |callback|
98  // with the flush result.
99  void OnFlushDone(const FlushDoneCallback& callback,
100                   const scoped_ptr<FlushResult>& result,
101                   const scoped_ptr<size_t>& bytes_written);
102
103  // Called when one type of dump has been ended. It continues to end the other
104  // dump if needed based on |context| and |incoming|, or calls the callback in
105  // |context| if no more dump needs to be ended.
106  void OnDumpEnded(EndDumpContext context, bool incoming, bool success);
107
108  // The max limit on the total size of incoming and outgoing dumps on disk.
109  const size_t max_dump_size_;
110
111  // The callback to call when the max size limit is reached.
112  const base::Closure max_dump_size_reached_callback_;
113
114  // The in-memory buffers for the uncompressed dumps.
115  std::vector<uint8> incoming_buffer_;
116  std::vector<uint8> outgoing_buffer_;
117
118  // The time when the first packet is dumped.
119  base::TimeTicks start_time_;
120
121  // The total on-disk size of the compressed incoming and outgoing dumps.
122  size_t total_dump_size_on_disk_;
123
124  // File thread workers must be called and deleted on the FILE thread.
125  scoped_ptr<FileThreadWorker> incoming_file_thread_worker_;
126  scoped_ptr<FileThreadWorker> outgoing_file_thread_worker_;
127
128  base::ThreadChecker thread_checker_;
129
130  base::WeakPtrFactory<WebRtcRtpDumpWriter> weak_ptr_factory_;
131
132  DISALLOW_COPY_AND_ASSIGN(WebRtcRtpDumpWriter);
133};
134
135#endif  // CHROME_BROWSER_MEDIA_WEBRTC_RTP_DUMP_WRITER_H_
136