Style fixes in FecReceiver and ProducerFec unit tests.
- Change some types to size_t.
- Update parameter ordering.
- Run 'git cl format'
- Moved 'using declarations' into unnamed namespaces.
- Removed "::webrtc::" prefix from some using declarations.
BUG=webrtc:5654
Review-Url: https://codereview.webrtc.org/2273353002
Cr-Original-Commit-Position: refs/heads/master@{#14475}
Cr-Mirrored-From: https://chromium.googlesource.com/external/webrtc
Cr-Mirrored-Commit: 71ca74798af8fd33a55ddd462945289b920103f2
diff --git a/modules/rtp_rtcp/source/fec_receiver_unittest.cc b/modules/rtp_rtcp/source/fec_receiver_unittest.cc
index 49db147..01ce2d1 100644
--- a/modules/rtp_rtcp/source/fec_receiver_unittest.cc
+++ b/modules/rtp_rtcp/source/fec_receiver_unittest.cc
@@ -25,17 +25,17 @@
namespace webrtc {
namespace {
-constexpr uint8_t kFecPayloadType = 96;
-} // namespace
-
using ::testing::_;
using ::testing::Args;
using ::testing::ElementsAreArray;
using ::testing::Return;
-using Packet = ::webrtc::ForwardErrorCorrection::Packet;
-using ::webrtc::test::fec::RawRtpPacket;
-using ::webrtc::test::fec::UlpfecPacketGenerator;
+using Packet = ForwardErrorCorrection::Packet;
+using test::fec::RawRtpPacket;
+using test::fec::UlpfecPacketGenerator;
+
+constexpr int kFecPayloadType = 96;
+} // namespace
class ReceiverFecTest : public ::testing::Test {
protected:
@@ -43,21 +43,21 @@
: fec_(ForwardErrorCorrection::CreateUlpfec()),
receiver_fec_(FecReceiver::Create(&rtp_data_callback_)) {}
- void EncodeFec(ForwardErrorCorrection::PacketList* media_packets,
- std::list<ForwardErrorCorrection::Packet*>* fec_packets,
- unsigned int num_fec_packets) {
- uint8_t protection_factor = num_fec_packets * 255 / media_packets->size();
- EXPECT_EQ(0, fec_->EncodeFec(*media_packets, protection_factor, 0, false,
+ void EncodeFec(const ForwardErrorCorrection::PacketList& media_packets,
+ size_t num_fec_packets,
+ std::list<ForwardErrorCorrection::Packet*>* fec_packets) {
+ uint8_t protection_factor = num_fec_packets * 255 / media_packets.size();
+ EXPECT_EQ(0, fec_->EncodeFec(media_packets, protection_factor, 0, false,
kFecMaskBursty, fec_packets));
ASSERT_EQ(num_fec_packets, fec_packets->size());
}
- void GenerateFrame(int num_media_packets,
- int frame_offset,
+ void GenerateFrame(size_t num_media_packets,
+ size_t frame_offset,
std::list<RawRtpPacket*>* media_rtp_packets,
ForwardErrorCorrection::PacketList* media_packets) {
generator_.NewFrame(num_media_packets);
- for (int i = 0; i < num_media_packets; ++i) {
+ for (size_t i = 0; i < num_media_packets; ++i) {
std::unique_ptr<RawRtpPacket> next_packet(
generator_.NextPacket(frame_offset + i, kRtpHeaderSize + 10));
media_rtp_packets->push_back(next_packet.get());
@@ -65,14 +65,15 @@
}
}
- void VerifyReconstructedMediaPacket(const RawRtpPacket* packet, int times) {
+ void VerifyReconstructedMediaPacket(const RawRtpPacket& packet,
+ size_t times) {
// Verify that the content of the reconstructed packet is equal to the
// content of |packet|, and that the same content is received |times| number
// of times in a row.
- EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, packet->length))
- .With(Args<0, 1>(ElementsAreArray(packet->data,
- packet->length)))
- .Times(times).WillRepeatedly(Return(true));
+ EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, packet.length))
+ .With(Args<0, 1>(ElementsAreArray(packet.data, packet.length)))
+ .Times(times)
+ .WillRepeatedly(Return(true));
}
void BuildAndAddRedMediaPacket(RawRtpPacket* packet) {
@@ -103,23 +104,23 @@
};
TEST_F(ReceiverFecTest, TwoMediaOneFec) {
- const unsigned int kNumFecPackets = 1u;
+ const size_t kNumFecPackets = 1;
std::list<RawRtpPacket*> media_rtp_packets;
ForwardErrorCorrection::PacketList media_packets;
GenerateFrame(2, 0, &media_rtp_packets, &media_packets);
std::list<ForwardErrorCorrection::Packet*> fec_packets;
- EncodeFec(&media_packets, &fec_packets, kNumFecPackets);
+ EncodeFec(media_packets, kNumFecPackets, &fec_packets);
// Recovery
auto it = media_rtp_packets.begin();
BuildAndAddRedMediaPacket(*it);
- VerifyReconstructedMediaPacket(*it, 1);
+ VerifyReconstructedMediaPacket(**it, 1);
EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
// Drop one media packet.
auto fec_it = fec_packets.begin();
BuildAndAddRedFecPacket(*fec_it);
++it;
- VerifyReconstructedMediaPacket(*it, 1);
+ VerifyReconstructedMediaPacket(**it, 1);
EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
FecPacketCounter counter = receiver_fec_->GetPacketCounter();
@@ -132,12 +133,12 @@
EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
.WillRepeatedly(Return(true));
- const unsigned int kNumFecPackets = 1u;
+ const size_t kNumFecPackets = 1;
std::list<RawRtpPacket*> media_rtp_packets;
ForwardErrorCorrection::PacketList media_packets;
GenerateFrame(2, 0, &media_rtp_packets, &media_packets);
std::list<ForwardErrorCorrection::Packet*> fec_packets;
- EncodeFec(&media_packets, &fec_packets, kNumFecPackets);
+ EncodeFec(media_packets, kNumFecPackets, &fec_packets);
ByteWriter<uint16_t>::WriteBigEndian(
&fec_packets.front()->data[fec_garbage_offset], 0x4711);
@@ -148,9 +149,9 @@
EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
FecPacketCounter counter = receiver_fec_->GetPacketCounter();
- EXPECT_EQ(2u, counter.num_packets);
- EXPECT_EQ(1u, counter.num_fec_packets);
- EXPECT_EQ(0u, counter.num_recovered_packets);
+ EXPECT_EQ(2U, counter.num_packets);
+ EXPECT_EQ(1U, counter.num_fec_packets);
+ EXPECT_EQ(0U, counter.num_recovered_packets);
}
TEST_F(ReceiverFecTest, InjectGarbageFecHeaderLengthRecovery) {
@@ -165,100 +166,100 @@
}
TEST_F(ReceiverFecTest, TwoMediaTwoFec) {
- const unsigned int kNumFecPackets = 2u;
+ const size_t kNumFecPackets = 2;
std::list<RawRtpPacket*> media_rtp_packets;
ForwardErrorCorrection::PacketList media_packets;
GenerateFrame(2, 0, &media_rtp_packets, &media_packets);
std::list<ForwardErrorCorrection::Packet*> fec_packets;
- EncodeFec(&media_packets, &fec_packets, kNumFecPackets);
+ EncodeFec(media_packets, kNumFecPackets, &fec_packets);
// Recovery
// Drop both media packets.
auto it = media_rtp_packets.begin();
auto fec_it = fec_packets.begin();
BuildAndAddRedFecPacket(*fec_it);
- VerifyReconstructedMediaPacket(*it, 1);
+ VerifyReconstructedMediaPacket(**it, 1);
EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
++fec_it;
BuildAndAddRedFecPacket(*fec_it);
++it;
- VerifyReconstructedMediaPacket(*it, 1);
+ VerifyReconstructedMediaPacket(**it, 1);
EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
}
TEST_F(ReceiverFecTest, TwoFramesOneFec) {
- const unsigned int kNumFecPackets = 1u;
+ const size_t kNumFecPackets = 1;
std::list<RawRtpPacket*> media_rtp_packets;
ForwardErrorCorrection::PacketList media_packets;
GenerateFrame(1, 0, &media_rtp_packets, &media_packets);
GenerateFrame(1, 1, &media_rtp_packets, &media_packets);
std::list<ForwardErrorCorrection::Packet*> fec_packets;
- EncodeFec(&media_packets, &fec_packets, kNumFecPackets);
+ EncodeFec(media_packets, kNumFecPackets, &fec_packets);
// Recovery
auto it = media_rtp_packets.begin();
BuildAndAddRedMediaPacket(media_rtp_packets.front());
- VerifyReconstructedMediaPacket(*it, 1);
+ VerifyReconstructedMediaPacket(**it, 1);
EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
// Drop one media packet.
BuildAndAddRedFecPacket(fec_packets.front());
++it;
- VerifyReconstructedMediaPacket(*it, 1);
+ VerifyReconstructedMediaPacket(**it, 1);
EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
}
TEST_F(ReceiverFecTest, OneCompleteOneUnrecoverableFrame) {
- const unsigned int kNumFecPackets = 1u;
+ const size_t kNumFecPackets = 1;
std::list<RawRtpPacket*> media_rtp_packets;
ForwardErrorCorrection::PacketList media_packets;
GenerateFrame(1, 0, &media_rtp_packets, &media_packets);
GenerateFrame(2, 1, &media_rtp_packets, &media_packets);
std::list<ForwardErrorCorrection::Packet*> fec_packets;
- EncodeFec(&media_packets, &fec_packets, kNumFecPackets);
+ EncodeFec(media_packets, kNumFecPackets, &fec_packets);
// Recovery
auto it = media_rtp_packets.begin();
BuildAndAddRedMediaPacket(*it); // First frame: one packet.
- VerifyReconstructedMediaPacket(*it, 1);
+ VerifyReconstructedMediaPacket(**it, 1);
EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
++it;
BuildAndAddRedMediaPacket(*it); // First packet of second frame.
- VerifyReconstructedMediaPacket(*it, 1);
+ VerifyReconstructedMediaPacket(**it, 1);
EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
}
TEST_F(ReceiverFecTest, MaxFramesOneFec) {
- const unsigned int kNumFecPackets = 1u;
- const unsigned int kNumMediaPackets = 48u;
+ const size_t kNumFecPackets = 1;
+ const size_t kNumMediaPackets = 48;
std::list<RawRtpPacket*> media_rtp_packets;
ForwardErrorCorrection::PacketList media_packets;
- for (unsigned int i = 0; i < kNumMediaPackets; ++i) {
+ for (size_t i = 0; i < kNumMediaPackets; ++i) {
GenerateFrame(1, i, &media_rtp_packets, &media_packets);
}
std::list<ForwardErrorCorrection::Packet*> fec_packets;
- EncodeFec(&media_packets, &fec_packets, kNumFecPackets);
+ EncodeFec(media_packets, kNumFecPackets, &fec_packets);
// Recovery
auto it = media_rtp_packets.begin();
++it; // Drop first packet.
for (; it != media_rtp_packets.end(); ++it) {
BuildAndAddRedMediaPacket(*it);
- VerifyReconstructedMediaPacket(*it, 1);
+ VerifyReconstructedMediaPacket(**it, 1);
EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
}
BuildAndAddRedFecPacket(fec_packets.front());
it = media_rtp_packets.begin();
- VerifyReconstructedMediaPacket(*it, 1);
+ VerifyReconstructedMediaPacket(**it, 1);
EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec());
}
TEST_F(ReceiverFecTest, TooManyFrames) {
- const unsigned int kNumFecPackets = 1u;
- const unsigned int kNumMediaPackets = 49u;
+ const size_t kNumFecPackets = 1;
+ const size_t kNumMediaPackets = 49;
std::list<RawRtpPacket*> media_rtp_packets;
ForwardErrorCorrection::PacketList media_packets;
- for (unsigned int i = 0; i < kNumMediaPackets; ++i) {
+ for (size_t i = 0; i < kNumMediaPackets; ++i) {
GenerateFrame(1, i, &media_rtp_packets, &media_packets);
}
std::list<ForwardErrorCorrection::Packet*> fec_packets;
@@ -270,15 +271,15 @@
TEST_F(ReceiverFecTest, PacketNotDroppedTooEarly) {
// 1 frame with 2 media packets and one FEC packet. One media packet missing.
// Delay the FEC packet.
- Packet* delayed_fec = NULL;
- const unsigned int kNumFecPacketsBatch1 = 1u;
- const unsigned int kNumMediaPacketsBatch1 = 2u;
+ Packet* delayed_fec = nullptr;
+ const size_t kNumFecPacketsBatch1 = 1;
+ const size_t kNumMediaPacketsBatch1 = 2;
std::list<RawRtpPacket*> media_rtp_packets_batch1;
ForwardErrorCorrection::PacketList media_packets_batch1;
GenerateFrame(kNumMediaPacketsBatch1, 0, &media_rtp_packets_batch1,
&media_packets_batch1);
std::list<ForwardErrorCorrection::Packet*> fec_packets;
- EncodeFec(&media_packets_batch1, &fec_packets, kNumFecPacketsBatch1);
+ EncodeFec(media_packets_batch1, kNumFecPacketsBatch1, &fec_packets);
BuildAndAddRedMediaPacket(media_rtp_packets_batch1.front());
EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
@@ -287,10 +288,10 @@
delayed_fec = fec_packets.front();
// Fill the FEC decoder. No packets should be dropped.
- const unsigned int kNumMediaPacketsBatch2 = 46u;
+ const size_t kNumMediaPacketsBatch2 = 46;
std::list<RawRtpPacket*> media_rtp_packets_batch2;
ForwardErrorCorrection::PacketList media_packets_batch2;
- for (unsigned int i = 0; i < kNumMediaPacketsBatch2; ++i) {
+ for (size_t i = 0; i < kNumMediaPacketsBatch2; ++i) {
GenerateFrame(1, i, &media_rtp_packets_batch2, &media_packets_batch2);
}
for (auto it = media_rtp_packets_batch2.begin();
@@ -311,15 +312,15 @@
TEST_F(ReceiverFecTest, PacketDroppedWhenTooOld) {
// 1 frame with 2 media packets and one FEC packet. One media packet missing.
// Delay the FEC packet.
- Packet* delayed_fec = NULL;
- const unsigned int kNumFecPacketsBatch1 = 1u;
- const unsigned int kNumMediaPacketsBatch1 = 2u;
+ Packet* delayed_fec = nullptr;
+ const size_t kNumFecPacketsBatch1 = 1;
+ const size_t kNumMediaPacketsBatch1 = 2;
std::list<RawRtpPacket*> media_rtp_packets_batch1;
ForwardErrorCorrection::PacketList media_packets_batch1;
GenerateFrame(kNumMediaPacketsBatch1, 0, &media_rtp_packets_batch1,
&media_packets_batch1);
std::list<ForwardErrorCorrection::Packet*> fec_packets;
- EncodeFec(&media_packets_batch1, &fec_packets, kNumFecPacketsBatch1);
+ EncodeFec(media_packets_batch1, kNumFecPacketsBatch1, &fec_packets);
BuildAndAddRedMediaPacket(media_rtp_packets_batch1.front());
EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
@@ -328,10 +329,10 @@
delayed_fec = fec_packets.front();
// Fill the FEC decoder and force the last packet to be dropped.
- const unsigned int kNumMediaPacketsBatch2 = 48u;
+ const size_t kNumMediaPacketsBatch2 = 48;
std::list<RawRtpPacket*> media_rtp_packets_batch2;
ForwardErrorCorrection::PacketList media_packets_batch2;
- for (unsigned int i = 0; i < kNumMediaPacketsBatch2; ++i) {
+ for (size_t i = 0; i < kNumMediaPacketsBatch2; ++i) {
GenerateFrame(1, i, &media_rtp_packets_batch2, &media_packets_batch2);
}
for (auto it = media_rtp_packets_batch2.begin();
@@ -353,15 +354,15 @@
TEST_F(ReceiverFecTest, OldFecPacketDropped) {
// 49 frames with 2 media packets and one FEC packet. All media packets
// missing.
- const unsigned int kNumMediaPackets = 49 * 2;
+ const size_t kNumMediaPackets = 49 * 2;
std::list<RawRtpPacket*> media_rtp_packets;
ForwardErrorCorrection::PacketList media_packets;
- for (unsigned int i = 0; i < kNumMediaPackets / 2; ++i) {
+ for (size_t i = 0; i < kNumMediaPackets / 2; ++i) {
std::list<RawRtpPacket*> frame_media_rtp_packets;
ForwardErrorCorrection::PacketList frame_media_packets;
std::list<ForwardErrorCorrection::Packet*> fec_packets;
GenerateFrame(2, 0, &frame_media_rtp_packets, &frame_media_packets);
- EncodeFec(&frame_media_packets, &fec_packets, 1);
+ EncodeFec(frame_media_packets, 1, &fec_packets);
for (auto it = fec_packets.begin(); it != fec_packets.end(); ++it) {
// Only FEC packets inserted. No packets recoverable at this time.
BuildAndAddRedFecPacket(*it);
@@ -378,7 +379,7 @@
frame_media_rtp_packets.end());
}
// Insert the oldest media packet. The corresponding FEC packet is too old
- // and should've been dropped. Only the media packet we inserted will be
+ // and should have been dropped. Only the media packet we inserted will be
// returned.
BuildAndAddRedMediaPacket(media_rtp_packets.front());
EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _))
diff --git a/modules/rtp_rtcp/source/flexfec_header_reader_writer_unittest.cc b/modules/rtp_rtcp/source/flexfec_header_reader_writer_unittest.cc
index d0e3bd1..5d0e69c 100644
--- a/modules/rtp_rtcp/source/flexfec_header_reader_writer_unittest.cc
+++ b/modules/rtp_rtcp/source/flexfec_header_reader_writer_unittest.cc
@@ -28,8 +28,8 @@
namespace {
-using Packet = ::webrtc::ForwardErrorCorrection::Packet;
-using ReceivedFecPacket = ::webrtc::ForwardErrorCorrection::ReceivedFecPacket;
+using Packet = ForwardErrorCorrection::Packet;
+using ReceivedFecPacket = ForwardErrorCorrection::ReceivedFecPacket;
// General. Assume single-stream protection.
constexpr uint32_t kMediaSsrc = 1254983;
diff --git a/modules/rtp_rtcp/source/producer_fec_unittest.cc b/modules/rtp_rtcp/source/producer_fec_unittest.cc
index 4fc87f7..bf36c47 100644
--- a/modules/rtp_rtcp/source/producer_fec_unittest.cc
+++ b/modules/rtp_rtcp/source/producer_fec_unittest.cc
@@ -12,6 +12,7 @@
#include <memory>
#include <vector>
+#include "webrtc/base/basictypes.h"
#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
#include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h"
#include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
@@ -21,12 +22,12 @@
namespace webrtc {
namespace {
-constexpr uint8_t kFecPayloadType = 96;
-constexpr uint8_t kRedPayloadType = 97;
-} // namespace
+using test::fec::RawRtpPacket;
+using test::fec::UlpfecPacketGenerator;
-using ::webrtc::test::fec::RawRtpPacket;
-using ::webrtc::test::fec::UlpfecPacketGenerator;
+constexpr int kFecPayloadType = 96;
+constexpr int kRedPayloadType = 97;
+} // namespace
void VerifyHeader(uint16_t seq_num,
uint32_t timestamp,
@@ -41,8 +42,8 @@
EXPECT_EQ(marker_bit ? 0x80 : 0, data[1] & 0x80);
EXPECT_EQ(red_payload_type, data[1] & 0x7F);
EXPECT_EQ(seq_num, (data[2] << 8) + data[3]);
- uint32_t parsed_timestamp = (data[4] << 24) + (data[5] << 16) +
- (data[6] << 8) + data[7];
+ uint32_t parsed_timestamp =
+ (data[4] << 24) + (data[5] << 16) + (data[6] << 8) + data[7];
EXPECT_EQ(timestamp, parsed_timestamp);
EXPECT_EQ(static_cast<uint8_t>(fec_payload_type), data[kRtpHeaderSize]);
}
@@ -86,7 +87,7 @@
}
ByteWriter<uint16_t>::WriteBigEndian(&packet[2], p.seq_num);
producer_.AddRtpPacketAndGenerateFec(packet, p.payload_size, p.header_size);
- uint16_t num_fec_packets = producer_.NumAvailableFecPackets();
+ size_t num_fec_packets = producer_.NumAvailableFecPackets();
if (num_fec_packets > 0) {
std::vector<std::unique_ptr<RedPacket>> fec_packets =
producer_.GetFecPacketsAsRed(kRedPayloadType, kFecPayloadType, 100,
@@ -103,13 +104,13 @@
// (1) protection factor is high enough so that actual overhead over 1 frame
// of packets is within |kMaxExcessOverhead|, and (2) the total number of
// media packets for 1 frame is at least |minimum_media_packets_fec_|.
- const int kNumPackets = 4;
+ constexpr size_t kNumPackets = 4;
FecProtectionParams params = {15, 3, kFecMaskRandom};
std::list<RawRtpPacket*> rtp_packets;
generator_.NewFrame(kNumPackets);
producer_.SetFecParameters(¶ms, 0); // Expecting one FEC packet.
uint32_t last_timestamp = 0;
- for (int i = 0; i < kNumPackets; ++i) {
+ for (size_t i = 0; i < kNumPackets; ++i) {
RawRtpPacket* rtp_packet = generator_.NextPacket(i, 10);
rtp_packets.push_back(rtp_packet);
EXPECT_EQ(0, producer_.AddRtpPacketAndGenerateFec(
@@ -139,16 +140,16 @@
// |kNumFrames| is within |kMaxExcessOverhead|, and (2) the total number of
// media packets for |kNumFrames| frames is at least
// |minimum_media_packets_fec_|.
- const int kNumPackets = 2;
- const int kNumFrames = 2;
+ constexpr size_t kNumPackets = 2;
+ constexpr size_t kNumFrames = 2;
FecProtectionParams params = {15, 3, kFecMaskRandom};
std::list<RawRtpPacket*> rtp_packets;
producer_.SetFecParameters(¶ms, 0); // Expecting one FEC packet.
uint32_t last_timestamp = 0;
- for (int i = 0; i < kNumFrames; ++i) {
+ for (size_t i = 0; i < kNumFrames; ++i) {
generator_.NewFrame(kNumPackets);
- for (int j = 0; j < kNumPackets; ++j) {
+ for (size_t j = 0; j < kNumPackets; ++j) {
RawRtpPacket* rtp_packet = generator_.NextPacket(i * kNumPackets + j, 10);
rtp_packets.push_back(rtp_packet);
EXPECT_EQ(0, producer_.AddRtpPacketAndGenerateFec(
@@ -182,8 +183,9 @@
packet->header.header.timestamp, kRedPayloadType,
packet->header.header.payloadType, red_packet.get(),
true); // Marker bit set.
- for (int i = 0; i < 10; ++i)
+ for (int i = 0; i < 10; ++i) {
EXPECT_EQ(i, red_packet->data()[kRtpHeaderSize + 1 + i]);
+ }
delete packet;
}
diff --git a/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc b/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc
index dfeefbb..13774de 100644
--- a/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc
+++ b/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc
@@ -27,8 +27,8 @@
namespace {
-using Packet = ::webrtc::ForwardErrorCorrection::Packet;
-using ReceivedFecPacket = ::webrtc::ForwardErrorCorrection::ReceivedFecPacket;
+using Packet = ForwardErrorCorrection::Packet;
+using ReceivedFecPacket = ForwardErrorCorrection::ReceivedFecPacket;
constexpr uint32_t kMediaSsrc = 1254983;
constexpr uint16_t kMediaStartSeqNum = 825;
