Popular sites on the NTP: check that experiment group StartsWith (rather than IS...
[chromium-blink-merge.git] / chrome / browser / media / webrtc_rtp_dump_writer_unittest.cc
blobef4a60de198216d8018d78a84c74c2c743578ae0
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.
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"
20 static const size_t kMinimumRtpHeaderLength = 12;
22 static 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));
28 memset(&(*packet_header)[0], 0, packet_header->size());
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);
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));
45 class 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()) {}
52 virtual void SetUp() {
53 ASSERT_TRUE(temp_dir_->CreateUniqueTempDir());
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))));
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;
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_));
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_));
86 MOCK_METHOD2(OnEndDumpDone, void(bool, bool));
87 MOCK_METHOD0(OnMaxSizeReached, void(void));
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);
94 std::vector<uint8> decompressed_dump;
95 EXPECT_TRUE(Decompress(dump, &decompressed_dump));
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);
101 return true;
104 // Decompresses the |input| into |output|.
105 bool Decompress(std::string* input, std::vector<uint8>* output) {
106 z_stream stream = {0};
108 int result = inflateInit2(&stream, 15 + 16);
109 EXPECT_EQ(Z_OK, result);
111 output->resize(input->size() * 100);
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();
119 result = inflate(&stream, Z_FINISH);
120 DCHECK_EQ(Z_STREAM_END, result);
121 result = inflateEnd(&stream);
122 DCHECK_EQ(Z_OK, result);
124 output->resize(output->size() - stream.avail_out);
125 return true;
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);
135 *packet_count = 0;
136 size_t dump_pos = 0;
138 // Verifies the first line.
139 EXPECT_EQ(memcmp(&dump[0], kFirstLine, arraysize(kFirstLine) - 1), 0);
141 dump_pos += arraysize(kFirstLine) - 1;
142 EXPECT_GT(dump.size(), dump_pos);
144 // Skips the file header.
145 dump_pos += kDumpFileHeaderSize;
146 EXPECT_GT(dump.size(), dump_pos);
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;
160 EXPECT_GE(dump.size(), dump_pos + packet_dump_length);
161 dump_pos += packet_dump_length;
163 (*packet_count)++;
165 return true;
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;
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;
181 EXPECT_GE(dump_length, *packet_dump_length);
182 dump_pos += sizeof(uint16);
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;
190 dump_pos += sizeof(uint16);
192 // Skips the elapsed time field.
193 dump_pos += sizeof(uint32);
195 return IsValidRtpHeader(dump + dump_pos,
196 *packet_dump_length - kDumpHeaderLength);
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;
204 size_t cc_count = header[0] & 0x0F;
205 size_t header_length_without_extn = kMinimumRtpHeaderLength + 4 * cc_count;
207 if (length < header_length_without_extn)
208 return false;
210 uint16 extension_count = 0;
211 base::ReadBigEndian(
212 reinterpret_cast<const char*>(header + header_length_without_extn + 2),
213 &extension_count);
215 if (length < (extension_count + 1) * 4 + header_length_without_extn)
216 return false;
218 return true;
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_;
228 TEST_F(WebRtcRtpDumpWriterTest, NoDumpFileIfNoPacketDumped) {
229 // The scope is used to make sure the EXPECT_CALL is checked before exiting
230 // the scope.
232 EXPECT_CALL(*this, OnEndDumpDone(false, false));
234 writer_->EndDump(RTP_DUMP_BOTH,
235 base::Bind(&WebRtcRtpDumpWriterTest::OnEndDumpDone,
236 base::Unretained(this)));
238 content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
239 base::RunLoop().RunUntilIdle();
240 content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
241 base::RunLoop().RunUntilIdle();
243 EXPECT_FALSE(base::PathExists(incoming_dump_path_));
244 EXPECT_FALSE(base::PathExists(outgoing_dump_path_));
247 TEST_F(WebRtcRtpDumpWriterTest, WriteAndFlushSmallSizeDump) {
248 std::vector<uint8> packet_header;
249 CreateFakeRtpPacketHeader(1, 2, &packet_header);
251 writer_->WriteRtpPacket(
252 &packet_header[0], packet_header.size(), 100, true);
253 writer_->WriteRtpPacket(
254 &packet_header[0], packet_header.size(), 100, false);
256 // The scope is used to make sure the EXPECT_CALL is checked before exiting
257 // the scope.
259 EXPECT_CALL(*this, OnEndDumpDone(true, true));
261 writer_->EndDump(RTP_DUMP_BOTH,
262 base::Bind(&WebRtcRtpDumpWriterTest::OnEndDumpDone,
263 base::Unretained(this)));
265 content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
266 base::RunLoop().RunUntilIdle();
267 content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
268 base::RunLoop().RunUntilIdle();
271 VerifyDumps(1, 1);
274 TEST_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))));
283 std::vector<uint8> packet_header;
284 CreateFakeRtpPacketHeader(3, 4, &packet_header);
286 const size_t kPacketCount = 200;
287 // The scope is used to make sure the EXPECT_CALL is checked before exiting
288 // the scope.
290 EXPECT_CALL(*this, OnMaxSizeReached()).Times(testing::AtLeast(1));
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);
297 writer_->WriteRtpPacket(
298 &packet_header[0], packet_header.size(), 100, false);
301 EXPECT_CALL(*this, OnEndDumpDone(true, true));
303 writer_->EndDump(RTP_DUMP_BOTH,
304 base::Bind(&WebRtcRtpDumpWriterTest::OnEndDumpDone,
305 base::Unretained(this)));
307 content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
308 base::RunLoop().RunUntilIdle();
309 content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
310 base::RunLoop().RunUntilIdle();
312 VerifyDumps(kPacketCount, kPacketCount);
315 TEST_F(WebRtcRtpDumpWriterTest, DestroyWriterBeforeEndDumpCallback) {
316 EXPECT_CALL(*this, OnEndDumpDone(testing::_, testing::_)).Times(0);
318 writer_->EndDump(RTP_DUMP_BOTH,
319 base::Bind(&WebRtcRtpDumpWriterTest::OnEndDumpDone,
320 base::Unretained(this)));
322 writer_.reset();
324 content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
325 base::RunLoop().RunUntilIdle();
326 content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
327 base::RunLoop().RunUntilIdle();
330 TEST_F(WebRtcRtpDumpWriterTest, EndDumpsSeparately) {
331 std::vector<uint8> packet_header;
332 CreateFakeRtpPacketHeader(1, 2, &packet_header);
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);
341 // The scope is used to make sure the EXPECT_CALL is checked before exiting
342 // the scope.
344 EXPECT_CALL(*this, OnEndDumpDone(true, false));
345 EXPECT_CALL(*this, OnEndDumpDone(false, true));
347 writer_->EndDump(RTP_DUMP_INCOMING,
348 base::Bind(&WebRtcRtpDumpWriterTest::OnEndDumpDone,
349 base::Unretained(this)));
351 writer_->EndDump(RTP_DUMP_OUTGOING,
352 base::Bind(&WebRtcRtpDumpWriterTest::OnEndDumpDone,
353 base::Unretained(this)));
355 content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
356 base::RunLoop().RunUntilIdle();
357 content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
358 base::RunLoop().RunUntilIdle();
361 VerifyDumps(2, 1);