Style updates for ForwardErrorCorrection and related classes

webrtc/modules/rtp_rtcp/source/rtp_fec_unittest.cc

 /*
  *  Copyright (c) 2012 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.
  */
 
@@ skipping 586 matching lines @@
   const bool kUseUnequalProtection = false;
   const int kNumMediaPackets = 5;
   uint8_t kProtectionFactor = 60;
 
   fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets);
 
   // Create a new temporary packet list for generating FEC packets.
   // This list should have every other packet removed.
   PacketList protected_media_packets;
   int i = 0;
-  for (PacketList::iterator it = media_packet_list_.begin();
-       it != media_packet_list_.end(); ++it, ++i) {
+  for (auto it = media_packet_list_.begin(); it != media_packet_list_.end();

[stefan-webrtc, 2016/06/29 16:14:03]

Should be able to change this to a range-based loop and increment inside the
body instead

[brandtr, 2016/06/30 13:37:43]

See "1b" CL.

+       ++it, ++i) {
     if (i % 2 == 0) protected_media_packets.push_back(*it);
   }
 
   EXPECT_EQ(0, fec_->GenerateFEC(protected_media_packets, kProtectionFactor,
                                  kNumImportantPackets, kUseUnequalProtection,
                                  webrtc::kFecMaskBursty, &fec_packet_list_));
 
   // Expect 1 FEC packet.
   EXPECT_EQ(1, static_cast<int>(fec_packet_list_.size()));
 
@@ skipping 42 matching lines @@
   const bool kUseUnequalProtection = false;
   const int kNumMediaPackets = 21;
   uint8_t kProtectionFactor = 127;
 
   fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets);
 
   // Create a new temporary packet list for generating FEC packets.
   // This list should have every other packet removed.
   PacketList protected_media_packets;
   int i = 0;
-  for (PacketList::iterator it = media_packet_list_.begin();
-       it != media_packet_list_.end(); ++it, ++i) {
+  for (auto it = media_packet_list_.begin(); it != media_packet_list_.end();
+       ++it, ++i) {

[stefan-webrtc, 2016/06/29 16:14:03]

Same here

[brandtr, 2016/06/30 13:37:43]

See "1b" CL.

     if (i % 2 == 0) protected_media_packets.push_back(*it);
   }
 
   // Zero column insertion will have to extend the size of the packet
   // mask since the number of actual packets are 21, while the number
   // of protected packets are 11.
   EXPECT_EQ(0, fec_->GenerateFEC(protected_media_packets, kProtectionFactor,
                                  kNumImportantPackets, kUseUnequalProtection,
                                  webrtc::kFecMaskBursty, &fec_packet_list_));
 
@@ skipping 49 matching lines @@
   const bool kUseUnequalProtection = false;
   const int kNumMediaPackets = 21;
   uint8_t kProtectionFactor = 127;
 
   fec_seq_num_ = ConstructMediaPacketsSeqNum(kNumMediaPackets, 0xFFFF - 5);
 
   // Create a new temporary packet list for generating FEC packets.
   // This list should have every other packet removed.
   PacketList protected_media_packets;
   int i = 0;
-  for (PacketList::iterator it = media_packet_list_.begin();
-       it != media_packet_list_.end(); ++it, ++i) {
+  for (auto it = media_packet_list_.begin(); it != media_packet_list_.end();
+       ++it, ++i) {

[stefan-webrtc, 2016/06/29 16:14:03]

And here

[brandtr, 2016/06/30 13:37:43]

See "1b" CL.

     if (i % 2 == 0) protected_media_packets.push_back(*it);
   }
 
   // Zero column insertion will have to extend the size of the packet
   // mask since the number of actual packets are 21, while the number
   // of protected packets are 11.
   EXPECT_EQ(0, fec_->GenerateFEC(protected_media_packets, kProtectionFactor,
                                  kNumImportantPackets, kUseUnequalProtection,
                                  webrtc::kFecMaskBursty, &fec_packet_list_));
 
@@ skipping 60 matching lines @@
   // Check that the number of media and recovered packets are equal.
   if (media_packet_list_.size() != recovered_packet_list_.size()) {
     return false;
   }
 
   ForwardErrorCorrection::Packet* media_packet;
   ForwardErrorCorrection::RecoveredPacket* recovered_packet;
 
   bool recovery = true;
 
-  PacketList::iterator media_packet_list_item = media_packet_list_.begin();
-  RecoveredPacketList::iterator recovered_packet_list_item =
-      recovered_packet_list_.begin();
-  while (media_packet_list_item != media_packet_list_.end()) {
-    if (recovered_packet_list_item == recovered_packet_list_.end()) {
+  auto media_packet_list_it = media_packet_list_.cbegin();
+  auto recovered_packet_list_it = recovered_packet_list_.cbegin();
+  while (media_packet_list_it != media_packet_list_.end()) {

[stefan-webrtc, 2016/06/29 16:14:03]

Make this a range-based loop

[brandtr, 2016/06/30 13:37:43]

Rewrote using std::equal and custom predicate instead.

+    if (recovered_packet_list_it == recovered_packet_list_.end()) {
       return false;
     }
-    media_packet = *media_packet_list_item;
-    recovered_packet = *recovered_packet_list_item;
+    media_packet = *media_packet_list_it;
+    recovered_packet = *recovered_packet_list_it;
     if (recovered_packet->pkt->length != media_packet->length) {
       return false;
     }
     if (memcmp(recovered_packet->pkt->data, media_packet->data,
                media_packet->length) != 0) {
       return false;
     }
-    media_packet_list_item++;
-    recovered_packet_list_item++;
+    media_packet_list_it++;
+    recovered_packet_list_it++;
   }
   return recovery;
 }
 
 void RtpFecTest::NetworkReceivedPackets() {
   const bool kFecPacket = true;
   ReceivedPackets(media_packet_list_, media_loss_mask_, !kFecPacket);
   ReceivedPackets(fec_packet_list_, fec_loss_mask_, kFecPacket);
 }
 
 void RtpFecTest::ReceivedPackets(const PacketList& packet_list, int* loss_mask,
                                  bool is_fec) {
   ForwardErrorCorrection::Packet* packet;
   ForwardErrorCorrection::ReceivedPacket* received_packet;
   int seq_num = fec_seq_num_;
   int packet_idx = 0;
 
-  PacketList::const_iterator packet_list_item = packet_list.begin();
-
-  while (packet_list_item != packet_list.end()) {
-    packet = *packet_list_item;
+  auto packet_list_it = packet_list.cbegin();
+  while (packet_list_it != packet_list.end()) {

[stefan-webrtc, 2016/06/29 16:14:03]

and this, I think?

[brandtr, 2016/06/30 13:37:43]

Done.

+    packet = *packet_list_it;
     if (loss_mask[packet_idx] == 0) {
       received_packet = new ForwardErrorCorrection::ReceivedPacket;
       received_packet->pkt = new ForwardErrorCorrection::Packet;
       received_packet_list_.push_back(received_packet);
       received_packet->pkt->length = packet->length;
       memcpy(received_packet->pkt->data, packet->data, packet->length);
       received_packet->is_fec = is_fec;
       if (!is_fec) {
         // For media packets, the sequence number and marker bit is
         // obtained from RTP header. These were set in ConstructMediaPackets().
         received_packet->seq_num =
             webrtc::ByteReader<uint16_t>::ReadBigEndian(&packet->data[2]);
       } else {
         // The sequence number, marker bit, and ssrc number are defined in the
         // RTP header of the FEC packet, which is not constructed in this test.
         // So we set these values below based on the values generated in
         // ConstructMediaPackets().
         received_packet->seq_num = seq_num;
         // The ssrc value for FEC packets is set to the one used for the
         // media packets in ConstructMediaPackets().
         received_packet->ssrc = ssrc_;
       }
     }
     packet_idx++;
-    packet_list_item++;
+    packet_list_it++;
     // Sequence number of FEC packets are defined as increment by 1 from
     // last media packet in frame.
     if (is_fec) seq_num++;
   }
 }
 
 int RtpFecTest::ConstructMediaPacketsSeqNum(int num_media_packets,
                                             int start_seq_num) {
-  assert(num_media_packets > 0);
+  RTC_DCHECK_GT(num_media_packets, 0);
   ForwardErrorCorrection::Packet* media_packet = NULL;
   int sequence_number = start_seq_num;
   int time_stamp = random_.Rand<int>();
 
   for (int i = 0; i < num_media_packets; ++i) {
     media_packet = new ForwardErrorCorrection::Packet;
     media_packet_list_.push_back(media_packet);
     const uint32_t kMinPacketSize = kRtpHeaderSize;
     const uint32_t kMaxPacketSize = IP_PACKET_SIZE - kRtpHeaderSize -
                                     kTransportOverhead -
@@ skipping 23 matching lines @@
                                                  time_stamp);
     webrtc::ByteWriter<uint32_t>::WriteBigEndian(&media_packet->data[8], ssrc_);
 
     // Generate random values for payload.
     for (size_t j = 12; j < media_packet->length; ++j) {
       media_packet->data[j] = random_.Rand<uint8_t>();
     }
     sequence_number++;
   }
   // Last packet, set marker bit.
-  assert(media_packet != NULL);
+  RTC_DCHECK(media_packet);
   media_packet->data[1] |= 0x80;
   return sequence_number;
 }
 
 int RtpFecTest::ConstructMediaPackets(int num_media_packets) {
   return ConstructMediaPacketsSeqNum(num_media_packets, random_.Rand<int>());
 }