1 /*
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include <string.h>
12
13 #include <list>
14
15 #include "testing/gmock/include/gmock/gmock.h"
16 #include "testing/gtest/include/gtest/gtest.h"
17 #include "webrtc/base/scoped_ptr.h"
18 #include "webrtc/modules/rtp_rtcp/include/fec_receiver.h"
19 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
20 #include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
21 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
22 #include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h"
23 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
24
25 using ::testing::_;
26 using ::testing::Args;
27 using ::testing::ElementsAreArray;
28 using ::testing::Return;
29
30 namespace webrtc {
31
32 class ReceiverFecTest : public ::testing::Test {
33 protected:
SetUp()34 virtual void SetUp() {
35 fec_.reset(new ForwardErrorCorrection());
36 receiver_fec_.reset(FecReceiver::Create(&rtp_data_callback_));
37 generator_.reset(new FrameGenerator());
38 }
39
GenerateFEC(std::list<Packet * > * media_packets,std::list<Packet * > * fec_packets,unsigned int num_fec_packets)40 void GenerateFEC(std::list<Packet*>* media_packets,
41 std::list<Packet*>* fec_packets,
42 unsigned int num_fec_packets) {
43 uint8_t protection_factor = num_fec_packets * 255 / media_packets->size();
44 EXPECT_EQ(0, fec_->GenerateFEC(*media_packets, protection_factor,
45 0, false, kFecMaskBursty, fec_packets));
46 ASSERT_EQ(num_fec_packets, fec_packets->size());
47 }
48
GenerateFrame(int num_media_packets,int frame_offset,std::list<RtpPacket * > * media_rtp_packets,std::list<Packet * > * media_packets)49 void GenerateFrame(int num_media_packets, int frame_offset,
50 std::list<RtpPacket*>* media_rtp_packets,
51 std::list<Packet*>* media_packets) {
52 generator_->NewFrame(num_media_packets);
53 for (int i = 0; i < num_media_packets; ++i) {
54 media_rtp_packets->push_back(
55 generator_->NextPacket(frame_offset + i, kRtpHeaderSize + 10));
56 media_packets->push_back(media_rtp_packets->back());
57 }
58 }
59
VerifyReconstructedMediaPacket(const RtpPacket * packet,int times)60 void VerifyReconstructedMediaPacket(const RtpPacket* packet, int times) {
61 // Verify that the content of the reconstructed packet is equal to the
62 // content of |packet|, and that the same content is received |times| number
63 // of times in a row.
64 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, packet->length))
65 .With(Args<0, 1>(ElementsAreArray(packet->data,
66 packet->length)))
67 .Times(times).WillRepeatedly(Return(true));
68 }
69
BuildAndAddRedMediaPacket(RtpPacket * packet)70 void BuildAndAddRedMediaPacket(RtpPacket* packet) {
71 RtpPacket* red_packet = generator_->BuildMediaRedPacket(packet);
72 EXPECT_EQ(0, receiver_fec_->AddReceivedRedPacket(
73 red_packet->header.header, red_packet->data,
74 red_packet->length, kFecPayloadType));
75 delete red_packet;
76 }
77
BuildAndAddRedFecPacket(Packet * packet)78 void BuildAndAddRedFecPacket(Packet* packet) {
79 RtpPacket* red_packet = generator_->BuildFecRedPacket(packet);
80 EXPECT_EQ(0, receiver_fec_->AddReceivedRedPacket(
81 red_packet->header.header, red_packet->data,
82 red_packet->length, kFecPayloadType));
83 delete red_packet;
84 }
85
86 void InjectGarbagePacketLength(size_t fec_garbage_offset);
87 static void SurvivesMaliciousPacket(const uint8_t* data,
88 size_t length,
89 uint8_t ulpfec_payload_type);
90
91 MockRtpData rtp_data_callback_;
92 rtc::scoped_ptr<ForwardErrorCorrection> fec_;
93 rtc::scoped_ptr<FecReceiver> receiver_fec_;
94 rtc::scoped_ptr<FrameGenerator> generator_;
95 };
96
DeletePackets(std::list<Packet * > * packets)97 void DeletePackets(std::list<Packet*>* packets) {
98 while (!packets->empty()) {
99 delete packets->front();
100 packets->pop_front();
101 }
102 }
103
TEST_F(ReceiverFecTest,TwoMediaOneFec)104 TEST_F(ReceiverFecTest, TwoMediaOneFec) {
105 const unsigned int kNumFecPackets = 1u;
106 std::list<RtpPacket*> media_rtp_packets;
107 std::list<Packet*> media_packets;
108 GenerateFrame(2, 0, &media_rtp_packets, &media_packets);
109 std::list<Packet*> fec_packets;
110 GenerateFEC(&media_packets, &fec_packets, kNumFecPackets);
111
112 // Recovery
113 std::list<RtpPacket*>::iterator it = media_rtp_packets.begin();
114 BuildAndAddRedMediaPacket(*it);
115 VerifyReconstructedMediaPacket(*it, 1);
116 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
117 // Drop one media packet.
118 std::list<Packet*>::iterator fec_it = fec_packets.begin();
119 BuildAndAddRedFecPacket(*fec_it);
120 ++it;
121 VerifyReconstructedMediaPacket(*it, 1);
122 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
123
124 FecPacketCounter counter = receiver_fec_->GetPacketCounter();
125 EXPECT_EQ(2U, counter.num_packets);
126 EXPECT_EQ(1U, counter.num_fec_packets);
127 EXPECT_EQ(1U, counter.num_recovered_packets);
128
129 DeletePackets(&media_packets);
130 }
131
InjectGarbagePacketLength(size_t fec_garbage_offset)132 void ReceiverFecTest::InjectGarbagePacketLength(size_t fec_garbage_offset) {
133 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
134 .WillRepeatedly(Return(true));
135
136 const unsigned int kNumFecPackets = 1u;
137 std::list<RtpPacket*> media_rtp_packets;
138 std::list<Packet*> media_packets;
139 GenerateFrame(2, 0, &media_rtp_packets, &media_packets);
140 std::list<Packet*> fec_packets;
141 GenerateFEC(&media_packets, &fec_packets, kNumFecPackets);
142 ByteWriter<uint16_t>::WriteBigEndian(
143 &fec_packets.front()->data[fec_garbage_offset], 0x4711);
144
145 // Inject first media packet, then first FEC packet, skipping the second media
146 // packet to cause a recovery from the FEC packet.
147 BuildAndAddRedMediaPacket(media_rtp_packets.front());
148 BuildAndAddRedFecPacket(fec_packets.front());
149 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
150
151 FecPacketCounter counter = receiver_fec_->GetPacketCounter();
152 EXPECT_EQ(2u, counter.num_packets);
153 EXPECT_EQ(1u, counter.num_fec_packets);
154 EXPECT_EQ(0u, counter.num_recovered_packets);
155
156 DeletePackets(&media_packets);
157 }
158
TEST_F(ReceiverFecTest,InjectGarbageFecHeaderLengthRecovery)159 TEST_F(ReceiverFecTest, InjectGarbageFecHeaderLengthRecovery) {
160 // Byte offset 8 is the 'length recovery' field of the FEC header.
161 InjectGarbagePacketLength(8);
162 }
163
TEST_F(ReceiverFecTest,InjectGarbageFecLevelHeaderProtectionLength)164 TEST_F(ReceiverFecTest, InjectGarbageFecLevelHeaderProtectionLength) {
165 // Byte offset 10 is the 'protection length' field in the first FEC level
166 // header.
167 InjectGarbagePacketLength(10);
168 }
169
TEST_F(ReceiverFecTest,TwoMediaTwoFec)170 TEST_F(ReceiverFecTest, TwoMediaTwoFec) {
171 const unsigned int kNumFecPackets = 2u;
172 std::list<RtpPacket*> media_rtp_packets;
173 std::list<Packet*> media_packets;
174 GenerateFrame(2, 0, &media_rtp_packets, &media_packets);
175 std::list<Packet*> fec_packets;
176 GenerateFEC(&media_packets, &fec_packets, kNumFecPackets);
177
178 // Recovery
179 // Drop both media packets.
180 std::list<RtpPacket*>::iterator it = media_rtp_packets.begin();
181 std::list<Packet*>::iterator fec_it = fec_packets.begin();
182 BuildAndAddRedFecPacket(*fec_it);
183 VerifyReconstructedMediaPacket(*it, 1);
184 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
185 ++fec_it;
186 BuildAndAddRedFecPacket(*fec_it);
187 ++it;
188 VerifyReconstructedMediaPacket(*it, 1);
189 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
190
191 DeletePackets(&media_packets);
192 }
193
TEST_F(ReceiverFecTest,TwoFramesOneFec)194 TEST_F(ReceiverFecTest, TwoFramesOneFec) {
195 const unsigned int kNumFecPackets = 1u;
196 std::list<RtpPacket*> media_rtp_packets;
197 std::list<Packet*> media_packets;
198 GenerateFrame(1, 0, &media_rtp_packets, &media_packets);
199 GenerateFrame(1, 1, &media_rtp_packets, &media_packets);
200 std::list<Packet*> fec_packets;
201 GenerateFEC(&media_packets, &fec_packets, kNumFecPackets);
202
203 // Recovery
204 std::list<RtpPacket*>::iterator it = media_rtp_packets.begin();
205 BuildAndAddRedMediaPacket(media_rtp_packets.front());
206 VerifyReconstructedMediaPacket(*it, 1);
207 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
208 // Drop one media packet.
209 BuildAndAddRedFecPacket(fec_packets.front());
210 ++it;
211 VerifyReconstructedMediaPacket(*it, 1);
212 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
213
214 DeletePackets(&media_packets);
215 }
216
TEST_F(ReceiverFecTest,OneCompleteOneUnrecoverableFrame)217 TEST_F(ReceiverFecTest, OneCompleteOneUnrecoverableFrame) {
218 const unsigned int kNumFecPackets = 1u;
219 std::list<RtpPacket*> media_rtp_packets;
220 std::list<Packet*> media_packets;
221 GenerateFrame(1, 0, &media_rtp_packets, &media_packets);
222 GenerateFrame(2, 1, &media_rtp_packets, &media_packets);
223
224 std::list<Packet*> fec_packets;
225 GenerateFEC(&media_packets, &fec_packets, kNumFecPackets);
226
227 // Recovery
228 std::list<RtpPacket*>::iterator it = media_rtp_packets.begin();
229 BuildAndAddRedMediaPacket(*it); // First frame: one packet.
230 VerifyReconstructedMediaPacket(*it, 1);
231 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
232 ++it;
233 BuildAndAddRedMediaPacket(*it); // First packet of second frame.
234 VerifyReconstructedMediaPacket(*it, 1);
235 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
236
237 DeletePackets(&media_packets);
238 }
239
TEST_F(ReceiverFecTest,MaxFramesOneFec)240 TEST_F(ReceiverFecTest, MaxFramesOneFec) {
241 const unsigned int kNumFecPackets = 1u;
242 const unsigned int kNumMediaPackets = 48u;
243 std::list<RtpPacket*> media_rtp_packets;
244 std::list<Packet*> media_packets;
245 for (unsigned int i = 0; i < kNumMediaPackets; ++i) {
246 GenerateFrame(1, i, &media_rtp_packets, &media_packets);
247 }
248 std::list<Packet*> fec_packets;
249 GenerateFEC(&media_packets, &fec_packets, kNumFecPackets);
250
251 // Recovery
252 std::list<RtpPacket*>::iterator it = media_rtp_packets.begin();
253 ++it; // Drop first packet.
254 for (; it != media_rtp_packets.end(); ++it) {
255 BuildAndAddRedMediaPacket(*it);
256 VerifyReconstructedMediaPacket(*it, 1);
257 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
258 }
259 BuildAndAddRedFecPacket(fec_packets.front());
260 it = media_rtp_packets.begin();
261 VerifyReconstructedMediaPacket(*it, 1);
262 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
263
264 DeletePackets(&media_packets);
265 }
266
TEST_F(ReceiverFecTest,TooManyFrames)267 TEST_F(ReceiverFecTest, TooManyFrames) {
268 const unsigned int kNumFecPackets = 1u;
269 const unsigned int kNumMediaPackets = 49u;
270 std::list<RtpPacket*> media_rtp_packets;
271 std::list<Packet*> media_packets;
272 for (unsigned int i = 0; i < kNumMediaPackets; ++i) {
273 GenerateFrame(1, i, &media_rtp_packets, &media_packets);
274 }
275 std::list<Packet*> fec_packets;
276 EXPECT_EQ(-1, fec_->GenerateFEC(media_packets,
277 kNumFecPackets * 255 / kNumMediaPackets, 0,
278 false, kFecMaskBursty, &fec_packets));
279
280 DeletePackets(&media_packets);
281 }
282
TEST_F(ReceiverFecTest,PacketNotDroppedTooEarly)283 TEST_F(ReceiverFecTest, PacketNotDroppedTooEarly) {
284 // 1 frame with 2 media packets and one FEC packet. One media packet missing.
285 // Delay the FEC packet.
286 Packet* delayed_fec = NULL;
287 const unsigned int kNumFecPacketsBatch1 = 1u;
288 const unsigned int kNumMediaPacketsBatch1 = 2u;
289 std::list<RtpPacket*> media_rtp_packets_batch1;
290 std::list<Packet*> media_packets_batch1;
291 GenerateFrame(kNumMediaPacketsBatch1, 0, &media_rtp_packets_batch1,
292 &media_packets_batch1);
293 std::list<Packet*> fec_packets;
294 GenerateFEC(&media_packets_batch1, &fec_packets, kNumFecPacketsBatch1);
295
296 BuildAndAddRedMediaPacket(media_rtp_packets_batch1.front());
297 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
298 .Times(1).WillRepeatedly(Return(true));
299 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
300 delayed_fec = fec_packets.front();
301
302 // Fill the FEC decoder. No packets should be dropped.
303 const unsigned int kNumMediaPacketsBatch2 = 46u;
304 std::list<RtpPacket*> media_rtp_packets_batch2;
305 std::list<Packet*> media_packets_batch2;
306 for (unsigned int i = 0; i < kNumMediaPacketsBatch2; ++i) {
307 GenerateFrame(1, i, &media_rtp_packets_batch2, &media_packets_batch2);
308 }
309 for (std::list<RtpPacket*>::iterator it = media_rtp_packets_batch2.begin();
310 it != media_rtp_packets_batch2.end(); ++it) {
311 BuildAndAddRedMediaPacket(*it);
312 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
313 .Times(1).WillRepeatedly(Return(true));
314 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
315 }
316
317 // Add the delayed FEC packet. One packet should be reconstructed.
318 BuildAndAddRedFecPacket(delayed_fec);
319 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
320 .Times(1).WillRepeatedly(Return(true));
321 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
322
323 DeletePackets(&media_packets_batch1);
324 DeletePackets(&media_packets_batch2);
325 }
326
TEST_F(ReceiverFecTest,PacketDroppedWhenTooOld)327 TEST_F(ReceiverFecTest, PacketDroppedWhenTooOld) {
328 // 1 frame with 2 media packets and one FEC packet. One media packet missing.
329 // Delay the FEC packet.
330 Packet* delayed_fec = NULL;
331 const unsigned int kNumFecPacketsBatch1 = 1u;
332 const unsigned int kNumMediaPacketsBatch1 = 2u;
333 std::list<RtpPacket*> media_rtp_packets_batch1;
334 std::list<Packet*> media_packets_batch1;
335 GenerateFrame(kNumMediaPacketsBatch1, 0, &media_rtp_packets_batch1,
336 &media_packets_batch1);
337 std::list<Packet*> fec_packets;
338 GenerateFEC(&media_packets_batch1, &fec_packets, kNumFecPacketsBatch1);
339
340 BuildAndAddRedMediaPacket(media_rtp_packets_batch1.front());
341 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
342 .Times(1).WillRepeatedly(Return(true));
343 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
344 delayed_fec = fec_packets.front();
345
346 // Fill the FEC decoder and force the last packet to be dropped.
347 const unsigned int kNumMediaPacketsBatch2 = 48u;
348 std::list<RtpPacket*> media_rtp_packets_batch2;
349 std::list<Packet*> media_packets_batch2;
350 for (unsigned int i = 0; i < kNumMediaPacketsBatch2; ++i) {
351 GenerateFrame(1, i, &media_rtp_packets_batch2, &media_packets_batch2);
352 }
353 for (std::list<RtpPacket*>::iterator it = media_rtp_packets_batch2.begin();
354 it != media_rtp_packets_batch2.end(); ++it) {
355 BuildAndAddRedMediaPacket(*it);
356 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
357 .Times(1).WillRepeatedly(Return(true));
358 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
359 }
360
361 // Add the delayed FEC packet. No packet should be reconstructed since the
362 // first media packet of that frame has been dropped due to being too old.
363 BuildAndAddRedFecPacket(delayed_fec);
364 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
365 .Times(0);
366 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
367
368 DeletePackets(&media_packets_batch1);
369 DeletePackets(&media_packets_batch2);
370 }
371
TEST_F(ReceiverFecTest,OldFecPacketDropped)372 TEST_F(ReceiverFecTest, OldFecPacketDropped) {
373 // 49 frames with 2 media packets and one FEC packet. All media packets
374 // missing.
375 const unsigned int kNumMediaPackets = 49 * 2;
376 std::list<RtpPacket*> media_rtp_packets;
377 std::list<Packet*> media_packets;
378 for (unsigned int i = 0; i < kNumMediaPackets / 2; ++i) {
379 std::list<RtpPacket*> frame_media_rtp_packets;
380 std::list<Packet*> frame_media_packets;
381 std::list<Packet*> fec_packets;
382 GenerateFrame(2, 0, &frame_media_rtp_packets, &frame_media_packets);
383 GenerateFEC(&frame_media_packets, &fec_packets, 1);
384 for (std::list<Packet*>::iterator it = fec_packets.begin();
385 it != fec_packets.end(); ++it) {
386 // Only FEC packets inserted. No packets recoverable at this time.
387 BuildAndAddRedFecPacket(*it);
388 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
389 .Times(0);
390 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
391 }
392 media_packets.insert(media_packets.end(), frame_media_packets.begin(),
393 frame_media_packets.end());
394 media_rtp_packets.insert(media_rtp_packets.end(),
395 frame_media_rtp_packets.begin(),
396 frame_media_rtp_packets.end());
397 }
398 // Insert the oldest media packet. The corresponding FEC packet is too old
399 // and should've been dropped. Only the media packet we inserted will be
400 // returned.
401 BuildAndAddRedMediaPacket(media_rtp_packets.front());
402 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
403 .Times(1).WillRepeatedly(Return(true));
404 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
405
406 DeletePackets(&media_packets);
407 }
408
SurvivesMaliciousPacket(const uint8_t * data,size_t length,uint8_t ulpfec_payload_type)409 void ReceiverFecTest::SurvivesMaliciousPacket(const uint8_t* data,
410 size_t length,
411 uint8_t ulpfec_payload_type) {
412 webrtc::RTPHeader header;
413 rtc::scoped_ptr<webrtc::RtpHeaderParser> parser(
414 webrtc::RtpHeaderParser::Create());
415 ASSERT_TRUE(parser->Parse(data, length, &header));
416
417 webrtc::NullRtpData null_callback;
418 rtc::scoped_ptr<webrtc::FecReceiver> receiver_fec(
419 webrtc::FecReceiver::Create(&null_callback));
420
421 receiver_fec->AddReceivedRedPacket(header, data, length, ulpfec_payload_type);
422 }
423
TEST_F(ReceiverFecTest,TruncatedPacketWithFBitSet)424 TEST_F(ReceiverFecTest, TruncatedPacketWithFBitSet) {
425 const uint8_t kTruncatedPacket[] = {0x80,
426 0x2a,
427 0x68,
428 0x71,
429 0x29,
430 0xa1,
431 0x27,
432 0x3a,
433 0x29,
434 0x12,
435 0x2a,
436 0x98,
437 0xe0,
438 0x29};
439
440 SurvivesMaliciousPacket(kTruncatedPacket, sizeof(kTruncatedPacket), 100);
441 }
442
TEST_F(ReceiverFecTest,TruncatedPacketWithFBitSetEndingAfterFirstRedHeader)443 TEST_F(ReceiverFecTest, TruncatedPacketWithFBitSetEndingAfterFirstRedHeader) {
444 const uint8_t kPacket[] = {0x89,
445 0x27,
446 0x3a,
447 0x83,
448 0x27,
449 0x3a,
450 0x3a,
451 0xf3,
452 0x67,
453 0xbe,
454 0x2a,
455 0xa9,
456 0x27,
457 0x54,
458 0x3a,
459 0x3a,
460 0x2a,
461 0x67,
462 0x3a,
463 0xf3,
464 0x67,
465 0xbe,
466 0x2a,
467 0x27,
468 0xe6,
469 0xf6,
470 0x03,
471 0x3e,
472 0x29,
473 0x27,
474 0x21,
475 0x27,
476 0x2a,
477 0x29,
478 0x21,
479 0x4b,
480 0x29,
481 0x3a,
482 0x28,
483 0x29,
484 0xbf,
485 0x29,
486 0x2a,
487 0x26,
488 0x29,
489 0xae,
490 0x27,
491 0xa6,
492 0xf6,
493 0x00,
494 0x03,
495 0x3e};
496 SurvivesMaliciousPacket(kPacket, sizeof(kPacket), 100);
497 }
498
TEST_F(ReceiverFecTest,TruncatedPacketWithoutDataPastFirstBlock)499 TEST_F(ReceiverFecTest, TruncatedPacketWithoutDataPastFirstBlock) {
500 const uint8_t kPacket[] = {0x82,
501 0x38,
502 0x92,
503 0x38,
504 0x92,
505 0x38,
506 0xde,
507 0x2a,
508 0x11,
509 0xc8,
510 0xa3,
511 0xc4,
512 0x82,
513 0x38,
514 0x2a,
515 0x21,
516 0x2a,
517 0x28,
518 0x92,
519 0x38,
520 0x92,
521 0x00,
522 0x00,
523 0x0a,
524 0x3a,
525 0xc8,
526 0xa3,
527 0x3a,
528 0x27,
529 0xc4,
530 0x2a,
531 0x21,
532 0x2a,
533 0x28};
534 SurvivesMaliciousPacket(kPacket, sizeof(kPacket), 100);
535 }
536
537 } // namespace webrtc
538