Add FlexFEC header formatters. (pt. 5)

webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <string.h>
 
 #include <memory>
 #include <utility>
 
-#include "webrtc/test/gtest.h"
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/random.h"
 #include "webrtc/base/scoped_ref_ptr.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction_internal.h"
 #include "webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer.h"
+#include "webrtc/test/gtest.h"
 
 namespace webrtc {
 
 namespace {
 
 using Packet = ::webrtc::ForwardErrorCorrection::Packet;
 using ReceivedFecPacket = ::webrtc::ForwardErrorCorrection::ReceivedFecPacket;
 
 constexpr uint32_t kMediaSsrc = 1254983;
 constexpr uint16_t kMediaStartSeqNum = 825;
@@ skipping 14 matching lines @@
 }
 
 std::unique_ptr<Packet> WriteHeader(const uint8_t* packet_mask,
                                     size_t packet_mask_size) {
   UlpfecHeaderWriter writer;
   std::unique_ptr<Packet> written_packet(new Packet());
   written_packet->length = kMediaPacketLength;
   for (size_t i = 0; i < written_packet->length; ++i) {
     written_packet->data[i] = i;  // Actual content doesn't matter.
   }
-  writer.FinalizeFecHeader(kMediaStartSeqNum, packet_mask, packet_mask_size,
-                           written_packet.get());
+  writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, packet_mask,
+                           packet_mask_size, written_packet.get());
   return written_packet;
 }
 
 std::unique_ptr<ReceivedFecPacket> ReadHeader(const Packet& written_packet) {
   UlpfecHeaderReader reader;
   std::unique_ptr<ReceivedFecPacket> read_packet(new ReceivedFecPacket());
   read_packet->ssrc = kMediaSsrc;
   read_packet->pkt = rtc::scoped_refptr<Packet>(new Packet());
   memcpy(read_packet->pkt->data, written_packet.data, written_packet.length);
   read_packet->pkt->length = written_packet.length;
@@ skipping 77 matching lines @@
 TEST(UlpfecHeaderWriterTest, FinalizesSmallHeader) {
   const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitClear;
   auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
   Packet written_packet;
   written_packet.length = kMediaPacketLength;
   for (size_t i = 0; i < written_packet.length; ++i) {
     written_packet.data[i] = i;
   }
 
   UlpfecHeaderWriter writer;
-  writer.FinalizeFecHeader(kMediaStartSeqNum, packet_mask.get(),
+  writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, packet_mask.get(),
                            packet_mask_size, &written_packet);
 
   const uint8_t* packet = written_packet.data;
   EXPECT_EQ(0x00, packet[0] & 0x80);  // E bit.
   EXPECT_EQ(0x00, packet[0] & 0x40);  // L bit.
   EXPECT_EQ(kMediaStartSeqNum, ByteReader<uint16_t>::ReadBigEndian(packet + 2));
   EXPECT_EQ(
       static_cast<uint16_t>(kMediaPacketLength - kUlpfecHeaderSizeLBitClear),
       ByteReader<uint16_t>::ReadBigEndian(packet + 10));
   EXPECT_EQ(0, memcmp(packet + kUlpfecPacketMaskOffset, packet_mask.get(),
                       packet_mask_size));
 }
 
 TEST(UlpfecHeaderWriterTest, FinalizesLargeHeader) {
   const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
   auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
   Packet written_packet;
   written_packet.length = kMediaPacketLength;
   for (size_t i = 0; i < written_packet.length; ++i) {
     written_packet.data[i] = i;
   }
 
   UlpfecHeaderWriter writer;
-  writer.FinalizeFecHeader(kMediaStartSeqNum, packet_mask.get(),
+  writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, packet_mask.get(),
                            packet_mask_size, &written_packet);
 
   const uint8_t* packet = written_packet.data;
   EXPECT_EQ(0x00, packet[0] & 0x80);  // E bit.
   EXPECT_EQ(0x40, packet[0] & 0x40);  // L bit.
   EXPECT_EQ(kMediaStartSeqNum, ByteReader<uint16_t>::ReadBigEndian(packet + 2));
   EXPECT_EQ(
       static_cast<uint16_t>(kMediaPacketLength - kUlpfecHeaderSizeLBitSet),
       ByteReader<uint16_t>::ReadBigEndian(packet + 10));
   EXPECT_EQ(0, memcmp(packet + kUlpfecPacketMaskOffset, packet_mask.get(),
@@ skipping 42 matching lines @@
   auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
 
   auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
   auto read_packet = ReadHeader(*written_packet);
 
   VerifyHeaders(kUlpfecHeaderSizeLBitSet, packet_mask.get(), packet_mask_size,
                 *written_packet, *read_packet);
 }
 
 }  // namespace webrtc