Style updates to ProducerFec/FecReceiver.

webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc

Index: webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc
diff --git a/webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc b/webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc
index ea59dc1b4da2a3878028e758ca6754820a75c2d8..75ca2e5534a9ef5962d4075a509d8a022b55427e 100644
--- a/webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/producer_fec_unittest.cc
@@ -22,8 +22,8 @@ namespace webrtc {
 
 void VerifyHeader(uint16_t seq_num,
                   uint32_t timestamp,
-                  int red_pltype,
-                  int fec_pltype,
+                  int red_payload_type,
+                  int fec_payload_type,
                   RedPacket* packet,
                   bool marker_bit) {
   EXPECT_GT(packet->length(), kRtpHeaderSize);
@@ -31,30 +31,25 @@ void VerifyHeader(uint16_t seq_num,
   uint8_t* data = packet->data();
   // Marker bit not set.
   EXPECT_EQ(marker_bit ? 0x80 : 0, data[1] & 0x80);
-  EXPECT_EQ(red_pltype, data[1] & 0x7F);
+  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];
   EXPECT_EQ(timestamp, parsed_timestamp);
-  EXPECT_EQ(static_cast<uint8_t>(fec_pltype), data[kRtpHeaderSize]);
+  EXPECT_EQ(static_cast<uint8_t>(fec_payload_type), data[kRtpHeaderSize]);
 }
 
 class ProducerFecTest : public ::testing::Test {
  protected:
   virtual void SetUp() {
-    fec_ = new ForwardErrorCorrection();
-    producer_ = new ProducerFec(fec_);
-    generator_ = new FrameGenerator();
+    fec_.reset(new ForwardErrorCorrection());
+    producer_.reset(new ProducerFec(fec_.get()));
+    generator_.reset(new FrameGenerator());
   }
 
-  virtual void TearDown() {
-    delete producer_;
-    delete fec_;
-    delete generator_;
-  }
-  ForwardErrorCorrection* fec_;
-  ProducerFec* producer_;
-  FrameGenerator* generator_;
+  std::unique_ptr<ForwardErrorCorrection> fec_;

[danilchap, 2016/07/19 14:55:32]

may be use classes directly instead of smart pointers to them since they are
initialized once. (just need to remove SetUp and use initialization in
constructor instead):

class ProdcuerFecTest : public ::testing::Test {
 protected:
  ProducerFecTest() : producer_(&fec_) {}

  ForwardErrorCorrection fec_;
  ProducerFec producer_;
  FrameGenerator generator_;
}

[brandtr, 2016/07/21 09:03:58]

Done.

+  std::unique_ptr<ProducerFec> producer_;
+  std::unique_ptr<FrameGenerator> generator_;
 };
 
 // Verifies bug found via fuzzing, where a gap in the packet sequence caused us
@@ -92,15 +87,14 @@ TEST_F(ProducerFecTest, NoEmptyFecWithSeqNumGaps) {
     producer_->AddRtpPacketAndGenerateFec(packet, p.payload_size,
                                           p.header_size);
     uint16_t num_fec_packets = producer_->NumAvailableFecPackets();
-    std::vector<RedPacket*> fec_packets;
     if (num_fec_packets > 0) {
-      fec_packets =
-          producer_->GetFecPackets(kRedPayloadType, 99, 100, p.header_size);
+      std::vector<std::unique_ptr<RedPacket>> fec_packets =
+          producer_->GetFecPacketsAsRed(kRedPayloadType,
+                                        kFecPayloadType,
+                                        100,
+                                        p.header_size);
       EXPECT_EQ(num_fec_packets, fec_packets.size());
     }
-    for (RedPacket* fec_packet : fec_packets) {
-      delete fec_packet;
-    }
   }
 }
 
@@ -127,19 +121,19 @@ TEST_F(ProducerFecTest, OneFrameFec) {
   }
   EXPECT_TRUE(producer_->FecAvailable());
   uint16_t seq_num = generator_->NextSeqNum();
-  std::vector<RedPacket*> packets = producer_->GetFecPackets(kRedPayloadType,
-                                                             kFecPayloadType,
-                                                             seq_num,
-                                                             kRtpHeaderSize);
+  std::vector<std::unique_ptr<RedPacket>> packets =
+      producer_->GetFecPacketsAsRed(kRedPayloadType,
+                                    kFecPayloadType,
+                                    seq_num,
+                                    kRtpHeaderSize);
   EXPECT_FALSE(producer_->FecAvailable());
   ASSERT_EQ(1u, packets.size());
   VerifyHeader(seq_num, last_timestamp,
-               kRedPayloadType, kFecPayloadType, packets.front(), false);
+               kRedPayloadType, kFecPayloadType, packets.front().get(), false);
   while (!rtp_packets.empty()) {
     delete rtp_packets.front();
     rtp_packets.pop_front();
   }
-  delete packets.front();
 }
 
 TEST_F(ProducerFecTest, TwoFrameFec) {
@@ -171,27 +165,27 @@ TEST_F(ProducerFecTest, TwoFrameFec) {
   }
   EXPECT_TRUE(producer_->FecAvailable());
   uint16_t seq_num = generator_->NextSeqNum();
-  std::vector<RedPacket*> packets = producer_->GetFecPackets(kRedPayloadType,
-                                                             kFecPayloadType,
-                                                             seq_num,
-                                                             kRtpHeaderSize);
+  std::vector<std::unique_ptr<RedPacket>> packets =
+      producer_->GetFecPacketsAsRed(kRedPayloadType,
+                                    kFecPayloadType,
+                                    seq_num,
+                                    kRtpHeaderSize);
   EXPECT_FALSE(producer_->FecAvailable());
   ASSERT_EQ(1u, packets.size());
   VerifyHeader(seq_num, last_timestamp, kRedPayloadType, kFecPayloadType,
-               packets.front(), false);
+               packets.front().get(), false);
   while (!rtp_packets.empty()) {
     delete rtp_packets.front();
     rtp_packets.pop_front();
   }
-  delete packets.front();
 }
 
 TEST_F(ProducerFecTest, BuildRedPacket) {
   generator_->NewFrame(1);
   test::RawRtpPacket* packet = generator_->NextPacket(0, 10);
-  std::unique_ptr<RedPacket> red_packet(producer_->BuildRedPacket(
+  std::unique_ptr<RedPacket> red_packet = ProducerFec::BuildRedPacket(
       packet->data, packet->length - kRtpHeaderSize, kRtpHeaderSize,
-      kRedPayloadType));
+      kRedPayloadType);
   EXPECT_EQ(packet->length + 1, red_packet->length());
   VerifyHeader(packet->header.header.sequenceNumber,
                packet->header.header.timestamp,