Use std::unique_ptr in ForwardErrorCorrection.

webrtc/modules/rtp_rtcp/source/producer_fec.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 121 matching lines @@
                                             size_t payload_length,
                                             size_t rtp_header_length) {
   assert(fec_packets_.empty());
   if (media_packets_fec_.empty()) {
     params_ = new_params_;
   }
   bool complete_frame = false;
   const bool marker_bit = (data_buffer[1] & kRtpMarkerBitMask) ? true : false;
   if (media_packets_fec_.size() < ForwardErrorCorrection::kMaxMediaPackets) {
     // Generic FEC can only protect up to kMaxMediaPackets packets.
-    ForwardErrorCorrection::Packet* packet = new ForwardErrorCorrection::Packet;
+    std::unique_ptr<ForwardErrorCorrection::Packet> packet(
+        new ForwardErrorCorrection::Packet);

[stefan-webrtc, 2016/06/29 19:36:18]

()

[brandtr, 2016/06/30 14:05:55]

Done.

     packet->length = payload_length + rtp_header_length;
     memcpy(packet->data, data_buffer, packet->length);
-    media_packets_fec_.push_back(packet);
+    media_packets_fec_.push_back(std::move(packet));
   }
   if (marker_bit) {
     ++num_frames_;
     complete_frame = true;
   }
   // Produce FEC over at most |params_.max_fec_frames| frames, or as soon as:
   // (1) the excess overhead (actual overhead - requested/target overhead) is
   // less than |kMaxExcessOverhead|, and
   // (2) at least |minimum_media_packets_fec_| media packets is reached.
   if (complete_frame &&
@@ skipping 55 matching lines @@
                                                    size_t rtp_header_length) {
   std::vector<RedPacket*> fec_packets;
   fec_packets.reserve(fec_packets_.size());
   uint16_t sequence_number = first_seq_num;
   while (!fec_packets_.empty()) {
     // Build FEC packet. The FEC packets in |fec_packets_| doesn't
     // have RTP headers, so we're reusing the header from the last
     // media packet.
     ForwardErrorCorrection::Packet* packet_to_send = fec_packets_.front();
     ForwardErrorCorrection::Packet* last_media_packet =
-        media_packets_fec_.back();
+        media_packets_fec_.back().get();
 
     RedPacket* red_packet = new RedPacket(
         packet_to_send->length + kREDForFECHeaderLength + rtp_header_length);
     red_packet->CreateHeader(last_media_packet->data, rtp_header_length,
                              red_pl_type, fec_pl_type);
     red_packet->SetSeqNum(sequence_number++);
     red_packet->ClearMarkerBit();
     red_packet->AssignPayload(packet_to_send->data, packet_to_send->length);
 
     fec_packets.push_back(red_packet);
@@ skipping 11 matching lines @@
   // protection factor produced by video_coding module and how the FEC
   // generation is implemented.
   assert(!media_packets_fec_.empty());
   int num_fec_packets = fec_->GetNumberOfFecPackets(media_packets_fec_.size(),
                                                     params_.fec_rate);
   // Return the overhead in Q8.
   return (num_fec_packets << 8) / media_packets_fec_.size();
 }
 
 void ProducerFec::DeletePackets() {
-  while (!media_packets_fec_.empty()) {
-    delete media_packets_fec_.front();
-    media_packets_fec_.pop_front();
-  }
+  media_packets_fec_.clear();
   assert(media_packets_fec_.empty());
 }
 
 }  // namespace webrtc