Avoid circular dependency rtp_rtcp <-> paced_sender

webrtc/modules/rtp_rtcp/source/rtp_sender_video.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 86 matching lines @@
 
 void RTPSenderVideo::SendVideoPacket(uint8_t* data_buffer,
                                      const size_t payload_length,
                                      const size_t rtp_header_length,
                                      uint16_t seq_num,
                                      const uint32_t capture_timestamp,
                                      int64_t capture_time_ms,
                                      StorageType storage) {
   if (_rtpSender.SendToNetwork(data_buffer, payload_length, rtp_header_length,
                                capture_time_ms, storage,
-                               PacedSender::kNormalPriority) == 0) {
+                               RtpPacketSender::kNormalPriority) == 0) {
     _videoBitrate.Update(payload_length + rtp_header_length);
     TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                          "Video::PacketNormal", "timestamp", capture_timestamp,
                          "seqnum", seq_num);
   } else {
     LOG(LS_WARNING) << "Failed to send video packet " << seq_num;
   }
 }
 
 void RTPSenderVideo::SendVideoPacketAsRed(uint8_t* data_buffer,
@@ skipping 25 matching lines @@
           _payloadTypeRED, _payloadTypeFEC, next_fec_sequence_number,
           rtp_header_length);
       RTC_DCHECK_EQ(num_fec_packets, fec_packets.size());
       if (_retransmissionSettings & kRetransmitFECPackets)
         fec_storage = kAllowRetransmission;
     }
   }
   if (_rtpSender.SendToNetwork(
           red_packet->data(), red_packet->length() - rtp_header_length,
           rtp_header_length, capture_time_ms, media_packet_storage,
-          PacedSender::kNormalPriority) == 0) {
+          RtpPacketSender::kNormalPriority) == 0) {
     _videoBitrate.Update(red_packet->length());
     TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                          "Video::PacketRed", "timestamp", capture_timestamp,
                          "seqnum", media_seq_num);
   } else {
     LOG(LS_WARNING) << "Failed to send RED packet " << media_seq_num;
   }
   for (RedPacket* fec_packet : fec_packets) {
     if (_rtpSender.SendToNetwork(
             fec_packet->data(), fec_packet->length() - rtp_header_length,
             rtp_header_length, capture_time_ms, fec_storage,
-            PacedSender::kNormalPriority) == 0) {
+            RtpPacketSender::kNormalPriority) == 0) {
       _fecOverheadRate.Update(fec_packet->length());
       TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                            "Video::PacketFec", "timestamp", capture_timestamp,
                            "seqnum", next_fec_sequence_number);
     } else {
       LOG(LS_WARNING) << "Failed to send FEC packet "
                       << next_fec_sequence_number;
     }
     delete fec_packet;
     ++next_fec_sequence_number;
   }
 }
 
 int32_t RTPSenderVideo::SendRTPIntraRequest() {
   // RFC 2032
   // 5.2.1.  Full intra-frame Request (FIR) packet
 
   size_t length = 8;
   uint8_t data[8];
   data[0] = 0x80;
   data[1] = 192;
   data[2] = 0;
   data[3] = 1;  // length
 
   ByteWriter<uint32_t>::WriteBigEndian(data + 4, _rtpSender.SSRC());
 
   TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                        "Video::IntraRequest", "seqnum",
                        _rtpSender.SequenceNumber());
-  return _rtpSender.SendToNetwork(
-      data, 0, length, -1, kDontStore, PacedSender::kNormalPriority);
+  return _rtpSender.SendToNetwork(data, 0, length, -1, kDontStore,
+                                  RtpPacketSender::kNormalPriority);
 }
 
 void RTPSenderVideo::SetGenericFECStatus(const bool enable,
                                          const uint8_t payloadTypeRED,
                                          const uint8_t payloadTypeFEC) {
   CriticalSectionScoped cs(crit_.get());
   _fecEnabled = enable;
   _payloadTypeRED = payloadTypeRED;
   _payloadTypeFEC = payloadTypeFEC;
   memset(&delta_fec_params_, 0, sizeof(delta_fec_params_));
@@ skipping 163 matching lines @@
   CriticalSectionScoped cs(crit_.get());
   return _retransmissionSettings;
 }
 
 void RTPSenderVideo::SetSelectiveRetransmissions(uint8_t settings) {
   CriticalSectionScoped cs(crit_.get());
   _retransmissionSettings = settings;
 }
 
 }  // namespace webrtc