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#include "base/big_endian.h"
6#include "base/bind.h"
7#include "base/files/file_util.h"
8#include "base/files/scoped_temp_dir.h"
9#include "base/macros.h"
10#include "base/memory/scoped_ptr.h"
11#include "base/run_loop.h"
12#include "chrome/browser/media/webrtc_rtp_dump_writer.h"
13#include "content/public/browser/browser_thread.h"
14#include "content/public/test/test_browser_thread_bundle.h"
15#include "content/public/test/test_utils.h"
16#include "testing/gmock/include/gmock/gmock.h"
17#include "testing/gtest/include/gtest/gtest.h"
18#include "third_party/zlib/zlib.h"
19
20static const size_t kMinimumRtpHeaderLength = 12;
21
22static void CreateFakeRtpPacketHeader(size_t csrc_count,
23                                      size_t extension_header_count,
24                                      std::vector<uint8>* packet_header) {
25  packet_header->resize(kMinimumRtpHeaderLength + csrc_count * sizeof(uint32) +
26                        (extension_header_count + 1) * sizeof(uint32));
27
28  memset(&(*packet_header)[0], 0, packet_header->size());
29
30  // First byte format: vvpxcccc, where 'vv' is the version, 'p' is padding, 'x'
31  // is the extension bit, 'cccc' is the CSRC count.
32  (*packet_header)[0] = 0;
33  (*packet_header)[0] |= (0x2 << 6);  // version.
34  // The extension bit.
35  (*packet_header)[0] |= (extension_header_count > 0 ? (0x1 << 4) : 0);
36  (*packet_header)[0] |= (csrc_count & 0xf);
37
38  // Set extension length.
39  size_t offset = kMinimumRtpHeaderLength +
40                  (csrc_count & 0xf) * sizeof(uint32) + sizeof(uint16);
41  base::WriteBigEndian(reinterpret_cast<char*>(&(*packet_header)[offset]),
42                       static_cast<uint16>(extension_header_count));
43}
44
45class WebRtcRtpDumpWriterTest : public testing::Test {
46 public:
47  WebRtcRtpDumpWriterTest()
48      : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP |
49                       content::TestBrowserThreadBundle::REAL_FILE_THREAD),
50        temp_dir_(new base::ScopedTempDir()) {}
51
52  virtual void SetUp() {
53    ASSERT_TRUE(temp_dir_->CreateUniqueTempDir());
54
55    incoming_dump_path_ = temp_dir_->path().AppendASCII("rtpdump_recv");
56    outgoing_dump_path_ = temp_dir_->path().AppendASCII("rtpdump_send");
57    writer_.reset(new WebRtcRtpDumpWriter(
58        incoming_dump_path_,
59        outgoing_dump_path_,
60        4 * 1024 * 1024,
61        base::Bind(&WebRtcRtpDumpWriterTest::OnMaxSizeReached,
62                   base::Unretained(this))));
63  }
64
65  // Verifies that the dump contains records of |rtp_packet| repeated
66  // |packet_count| times.
67  void VerifyDumps(size_t incoming_packet_count, size_t outgoing_packet_count) {
68    std::string incoming_dump;
69    std::string outgoing_dump;
70
71    if (incoming_packet_count) {
72      EXPECT_TRUE(base::ReadFileToString(incoming_dump_path_, &incoming_dump));
73      EXPECT_TRUE(VerifyCompressedDump(&incoming_dump, incoming_packet_count));
74    } else {
75      EXPECT_FALSE(base::PathExists(incoming_dump_path_));
76    }
77
78    if (outgoing_packet_count) {
79      EXPECT_TRUE(base::ReadFileToString(outgoing_dump_path_, &outgoing_dump));
80      EXPECT_TRUE(VerifyCompressedDump(&outgoing_dump, outgoing_packet_count));
81    } else {
82      EXPECT_FALSE(base::PathExists(outgoing_dump_path_));
83    }
84  }
85
86  MOCK_METHOD2(OnEndDumpDone, void(bool, bool));
87  MOCK_METHOD0(OnMaxSizeReached, void(void));
88
89 protected:
90  // Verifies the compressed dump file contains the expected number of packets.
91  bool VerifyCompressedDump(std::string* dump, size_t expected_packet_count) {
92    EXPECT_GT(dump->size(), 0U);
93
94    std::vector<uint8> decompressed_dump;
95    EXPECT_TRUE(Decompress(dump, &decompressed_dump));
96
97    size_t actual_packet_count = 0;
98    EXPECT_TRUE(ReadDecompressedDump(decompressed_dump, &actual_packet_count));
99    EXPECT_EQ(expected_packet_count, actual_packet_count);
100
101    return true;
102  }
103
104  // Decompresses the |input| into |output|.
105  bool Decompress(std::string* input, std::vector<uint8>* output) {
106    z_stream stream = {0};
107
108    int result = inflateInit2(&stream, 15 + 16);
109    EXPECT_EQ(Z_OK, result);
110
111    output->resize(input->size() * 100);
112
113    stream.next_in =
114        reinterpret_cast<unsigned char*>(const_cast<char*>(&(*input)[0]));
115    stream.avail_in = input->size();
116    stream.next_out = &(*output)[0];
117    stream.avail_out = output->size();
118
119    result = inflate(&stream, Z_FINISH);
120    DCHECK_EQ(Z_STREAM_END, result);
121    result = inflateEnd(&stream);
122    DCHECK_EQ(Z_OK, result);
123
124    output->resize(output->size() - stream.avail_out);
125    return true;
126  }
127
128  // Tries to read |dump| as a rtpplay dump file and returns the number of
129  // packets found in the dump.
130  bool ReadDecompressedDump(const std::vector<uint8>& dump,
131                            size_t* packet_count) {
132    static const char kFirstLine[] = "#!rtpplay1.0 0.0.0.0/0\n";
133    static const size_t kDumpFileHeaderSize = 4 * sizeof(uint32);
134
135    *packet_count = 0;
136    size_t dump_pos = 0;
137
138    // Verifies the first line.
139    EXPECT_EQ(memcmp(&dump[0], kFirstLine, arraysize(kFirstLine) - 1), 0);
140
141    dump_pos += arraysize(kFirstLine) - 1;
142    EXPECT_GT(dump.size(), dump_pos);
143
144    // Skips the file header.
145    dump_pos += kDumpFileHeaderSize;
146    EXPECT_GT(dump.size(), dump_pos);
147
148    // Reads each packet dump.
149    while (dump_pos < dump.size()) {
150      size_t packet_dump_length = 0;
151      if (!VerifyPacketDump(&dump[dump_pos],
152                            dump.size() - dump_pos,
153                            &packet_dump_length)) {
154        DVLOG(0) << "Failed to read the packet dump for packet "
155                 << *packet_count << ", dump_pos = " << dump_pos
156                 << ", dump_length = " << dump.size();
157        return false;
158      }
159
160      EXPECT_GE(dump.size(), dump_pos + packet_dump_length);
161      dump_pos += packet_dump_length;
162
163      (*packet_count)++;
164    }
165    return true;
166  }
167
168  // Tries to read one packet dump starting at |dump| and returns the size of
169  // the packet dump.
170  bool VerifyPacketDump(const uint8* dump,
171                        size_t dump_length,
172                        size_t* packet_dump_length) {
173    static const size_t kDumpHeaderLength = 8;
174
175    size_t dump_pos = 0;
176    base::ReadBigEndian(reinterpret_cast<const char*>(dump + dump_pos),
177                        reinterpret_cast<uint16*>(packet_dump_length));
178    if (*packet_dump_length < kDumpHeaderLength + kMinimumRtpHeaderLength)
179      return false;
180
181    EXPECT_GE(dump_length, *packet_dump_length);
182    dump_pos += sizeof(uint16);
183
184    uint16 rtp_packet_length = 0;
185    base::ReadBigEndian(reinterpret_cast<const char*>(dump + dump_pos),
186                        &rtp_packet_length);
187    if (rtp_packet_length < kMinimumRtpHeaderLength)
188      return false;
189
190    dump_pos += sizeof(uint16);
191
192    // Skips the elapsed time field.
193    dump_pos += sizeof(uint32);
194
195    return IsValidRtpHeader(dump + dump_pos,
196                            *packet_dump_length - kDumpHeaderLength);
197  }
198
199  // Returns true if |header| is a valid RTP header.
200  bool IsValidRtpHeader(const uint8* header, size_t length) {
201    if ((header[0] & 0xC0) != 0x80)
202      return false;
203
204    size_t cc_count = header[0] & 0x0F;
205    size_t header_length_without_extn = kMinimumRtpHeaderLength + 4 * cc_count;
206
207    if (length < header_length_without_extn)
208      return false;
209
210    uint16 extension_count = 0;
211    base::ReadBigEndian(
212        reinterpret_cast<const char*>(header + header_length_without_extn + 2),
213        &extension_count);
214
215    if (length < (extension_count + 1) * 4 + header_length_without_extn)
216      return false;
217
218    return true;
219  }
220
221  content::TestBrowserThreadBundle thread_bundle_;
222  scoped_ptr<base::ScopedTempDir> temp_dir_;
223  base::FilePath incoming_dump_path_;
224  base::FilePath outgoing_dump_path_;
225  scoped_ptr<WebRtcRtpDumpWriter> writer_;
226};
227
228TEST_F(WebRtcRtpDumpWriterTest, NoDumpFileIfNoPacketDumped) {
229  // The scope is used to make sure the EXPECT_CALL is checked before exiting
230  // the scope.
231  {
232    EXPECT_CALL(*this, OnEndDumpDone(false, false));
233
234    writer_->EndDump(RTP_DUMP_BOTH,
235                     base::Bind(&WebRtcRtpDumpWriterTest::OnEndDumpDone,
236                                base::Unretained(this)));
237
238    content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
239    base::RunLoop().RunUntilIdle();
240    content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
241    base::RunLoop().RunUntilIdle();
242  }
243  EXPECT_FALSE(base::PathExists(incoming_dump_path_));
244  EXPECT_FALSE(base::PathExists(outgoing_dump_path_));
245}
246
247TEST_F(WebRtcRtpDumpWriterTest, WriteAndFlushSmallSizeDump) {
248  std::vector<uint8> packet_header;
249  CreateFakeRtpPacketHeader(1, 2, &packet_header);
250
251  writer_->WriteRtpPacket(
252      &packet_header[0], packet_header.size(), 100, true);
253  writer_->WriteRtpPacket(
254      &packet_header[0], packet_header.size(), 100, false);
255
256  // The scope is used to make sure the EXPECT_CALL is checked before exiting
257  // the scope.
258  {
259    EXPECT_CALL(*this, OnEndDumpDone(true, true));
260
261    writer_->EndDump(RTP_DUMP_BOTH,
262                     base::Bind(&WebRtcRtpDumpWriterTest::OnEndDumpDone,
263                                base::Unretained(this)));
264
265    content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
266    base::RunLoop().RunUntilIdle();
267    content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
268    base::RunLoop().RunUntilIdle();
269  }
270
271  VerifyDumps(1, 1);
272}
273
274TEST_F(WebRtcRtpDumpWriterTest, WriteOverMaxLimit) {
275  // Reset the writer with a small max size limit.
276  writer_.reset(new WebRtcRtpDumpWriter(
277      incoming_dump_path_,
278      outgoing_dump_path_,
279      100,
280      base::Bind(&WebRtcRtpDumpWriterTest::OnMaxSizeReached,
281                 base::Unretained(this))));
282
283  std::vector<uint8> packet_header;
284  CreateFakeRtpPacketHeader(3, 4, &packet_header);
285
286  const size_t kPacketCount = 200;
287  // The scope is used to make sure the EXPECT_CALL is checked before exiting
288  // the scope.
289  {
290    EXPECT_CALL(*this, OnMaxSizeReached()).Times(testing::AtLeast(1));
291
292    // Write enough packets to overflow the in-memory buffer and max limit.
293    for (size_t i = 0; i < kPacketCount; ++i) {
294      writer_->WriteRtpPacket(
295          &packet_header[0], packet_header.size(), 100, true);
296
297      writer_->WriteRtpPacket(
298          &packet_header[0], packet_header.size(), 100, false);
299    }
300
301    EXPECT_CALL(*this, OnEndDumpDone(true, true));
302
303    writer_->EndDump(RTP_DUMP_BOTH,
304                     base::Bind(&WebRtcRtpDumpWriterTest::OnEndDumpDone,
305                                base::Unretained(this)));
306
307    content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
308    base::RunLoop().RunUntilIdle();
309    content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
310    base::RunLoop().RunUntilIdle();
311  }
312  VerifyDumps(kPacketCount, kPacketCount);
313}
314
315TEST_F(WebRtcRtpDumpWriterTest, DestroyWriterBeforeEndDumpCallback) {
316  EXPECT_CALL(*this, OnEndDumpDone(testing::_, testing::_)).Times(0);
317
318  writer_->EndDump(RTP_DUMP_BOTH,
319                   base::Bind(&WebRtcRtpDumpWriterTest::OnEndDumpDone,
320                              base::Unretained(this)));
321
322  writer_.reset();
323
324  content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
325  base::RunLoop().RunUntilIdle();
326  content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
327  base::RunLoop().RunUntilIdle();
328}
329
330TEST_F(WebRtcRtpDumpWriterTest, EndDumpsSeparately) {
331  std::vector<uint8> packet_header;
332  CreateFakeRtpPacketHeader(1, 2, &packet_header);
333
334  writer_->WriteRtpPacket(
335      &packet_header[0], packet_header.size(), 100, true);
336  writer_->WriteRtpPacket(
337      &packet_header[0], packet_header.size(), 100, true);
338  writer_->WriteRtpPacket(
339      &packet_header[0], packet_header.size(), 100, false);
340
341  // The scope is used to make sure the EXPECT_CALL is checked before exiting
342  // the scope.
343  {
344    EXPECT_CALL(*this, OnEndDumpDone(true, false));
345    EXPECT_CALL(*this, OnEndDumpDone(false, true));
346
347    writer_->EndDump(RTP_DUMP_INCOMING,
348                     base::Bind(&WebRtcRtpDumpWriterTest::OnEndDumpDone,
349                                base::Unretained(this)));
350
351    writer_->EndDump(RTP_DUMP_OUTGOING,
352                     base::Bind(&WebRtcRtpDumpWriterTest::OnEndDumpDone,
353                                base::Unretained(this)));
354
355    content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
356    base::RunLoop().RunUntilIdle();
357    content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
358    base::RunLoop().RunUntilIdle();
359  }
360
361  VerifyDumps(2, 1);
362}
363