| OLD | NEW |
|---|
| (Empty) |
| 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/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 | |
| 20 static const size_t kMinimumRtpHeaderLength = 12; | |
| 21 | |
| 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)); | |
| 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 | |
| 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()) {} | |
| 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 | |
| 228 TEST_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 | |
| 247 TEST_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 | |
| 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)))); | |
| 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 | |
| 315 TEST_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 | |
| 330 TEST_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 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 307063003:
Revert 273745 "Implements RTP header dumping." due to memory leak (Closed)
Base URL: svn://svn.chromium.org/chrome/