Move rtcp packet classes from rtp_rtcp to rtp_rtcp_format target

Bug: None
Change-Id: I353228fd5b75bd4fceeaee1bb6fd07b01dac56a1
Reviewed-on: https://webrtc-review.googlesource.com/1480
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Elad Alon <eladalon@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#19867}

modules/rtp_rtcp/source/rtcp_packet/bye.cc

@@ -97,7 +97,7 @@ bool Bye::Create(uint8_t* packet,
   }
   // Store the reason to leave.
   if (!reason_.empty()) {
-    uint8_t reason_length = reason_.size();
+    uint8_t reason_length = static_cast<uint8_t>(reason_.size());
     packet[(*index)++] = reason_length;
     memcpy(&packet[*index], reason_.data(), reason_length);
     *index += reason_length;

modules/rtp_rtcp/source/rtcp_packet/dlrr.cc

@@ -13,6 +13,7 @@
 #include "modules/rtp_rtcp/source/byte_io.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
+#include "rtc_base/safe_conversions.h"
 
 namespace webrtc {
 namespace rtcp {
@@ -75,7 +76,8 @@ void Dlrr::Create(uint8_t* buffer) const {
   const uint8_t kReserved = 0;
   buffer[0] = kBlockType;
   buffer[1] = kReserved;
-  ByteWriter<uint16_t>::WriteBigEndian(&buffer[2], 3 * sub_blocks_.size());
+  ByteWriter<uint16_t>::WriteBigEndian(
+      &buffer[2], rtc::dchecked_cast<uint16_t>(3 * sub_blocks_.size()));
   // Create sub blocks.
   uint8_t* write_at = buffer + kBlockHeaderLength;
   for (const ReceiveTimeInfo& sub_block : sub_blocks_) {

modules/rtp_rtcp/source/rtcp_packet/remb.cc

@@ -125,7 +125,7 @@ bool Remb::Create(uint8_t* packet,
     mantissa >>= 1;
     ++exponenta;
   }
-  packet[(*index)++] = ssrcs_.size();
+  packet[(*index)++] = static_cast<uint8_t>(ssrcs_.size());
   packet[(*index)++] = (exponenta << 2) | (mantissa >> 16);
   ByteWriter<uint16_t>::WriteBigEndian(packet + *index, mantissa & 0xffff);
   *index += sizeof(uint16_t);

modules/rtp_rtcp/source/rtcp_packet/sdes.cc

@@ -173,8 +173,8 @@ bool Sdes::Create(uint8_t* packet,
   for (const Sdes::Chunk& chunk : chunks_) {
     ByteWriter<uint32_t>::WriteBigEndian(&packet[*index + 0], chunk.ssrc);
     ByteWriter<uint8_t>::WriteBigEndian(&packet[*index + 4], kCnameTag);
-    ByteWriter<uint8_t>::WriteBigEndian(&packet[*index + 5],
-                                        chunk.cname.size());
+    ByteWriter<uint8_t>::WriteBigEndian(
+        &packet[*index + 5], static_cast<uint8_t>(chunk.cname.size()));
     memcpy(&packet[*index + 6], chunk.cname.data(), chunk.cname.size());
     *index += (6 + chunk.cname.size());
 

modules/rtp_rtcp/source/rtcp_packet/target_bitrate.cc

@@ -12,6 +12,7 @@
 
 #include "modules/rtp_rtcp/source/byte_io.h"
 #include "rtc_base/checks.h"
+#include "rtc_base/safe_conversions.h"
 
 namespace webrtc {
 namespace rtcp {
@@ -61,8 +62,10 @@ TargetBitrate::BitrateItem::BitrateItem(uint8_t spatial_layer,
 //  If VP9 SVC is used, there will be only one SSRC, so each spatial and
 //  temporal layer combo used shall be specified in the TargetBitrate packet.
 
-TargetBitrate::TargetBitrate() {}
-TargetBitrate::~TargetBitrate() {}
+TargetBitrate::TargetBitrate() = default;
+TargetBitrate::TargetBitrate(const TargetBitrate&) = default;
+TargetBitrate& TargetBitrate::operator=(const TargetBitrate&) = default;
+TargetBitrate::~TargetBitrate() = default;
 
 void TargetBitrate::Parse(const uint8_t* block, uint16_t block_length) {
   // Validate block header (should already have been parsed and checked).
@@ -107,7 +110,8 @@ size_t TargetBitrate::BlockLength() const {
 void TargetBitrate::Create(uint8_t* buffer) const {
   buffer[0] = kBlockType;
   buffer[1] = 0;  // Reserved.
-  const size_t block_length_words = (BlockLength() / 4) - 1;
+  uint16_t block_length_words =
+      rtc::dchecked_cast<uint16_t>((BlockLength() / 4) - 1);
   ByteWriter<uint16_t>::WriteBigEndian(&buffer[2], block_length_words);
 
   size_t index = kTargetBitrateHeaderSizeBytes;

modules/rtp_rtcp/source/rtcp_packet/target_bitrate.h

@@ -37,6 +37,8 @@ class TargetBitrate {
   };
 
   TargetBitrate();
+  TargetBitrate(const TargetBitrate&);
+  TargetBitrate& operator=(const TargetBitrate&);
   ~TargetBitrate();
 
   void AddTargetBitrate(uint8_t spatial_layer,

modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc

@@ -38,7 +38,7 @@ constexpr size_t kMaxSizeBytes = (1 << 16) * 4;
 // * 8 bytes FeedbackPacket header.
 // * 2 bytes for one chunk.
 constexpr size_t kMinPayloadSizeBytes = 8 + 8 + 2;
-constexpr size_t kBaseScaleFactor =
+constexpr int kBaseScaleFactor =
     TransportFeedback::kDeltaScaleFactor * (1 << 8);
 constexpr int64_t kTimeWrapPeriodUs = (1ll << 24) * kBaseScaleFactor;
 
@@ -116,7 +116,7 @@ class TransportFeedback::LastChunk {
   void DecodeRunLength(uint16_t chunk, size_t max_size);
 
   DeltaSize delta_sizes_[kMaxVectorCapacity];
-  uint16_t size_;
+  size_t size_;
   bool all_same_;
   bool has_large_delta_;
 };
@@ -291,14 +291,14 @@ void TransportFeedback::LastChunk::DecodeTwoBit(uint16_t chunk,
 uint16_t TransportFeedback::LastChunk::EncodeRunLength() const {
   RTC_DCHECK(all_same_);
   RTC_DCHECK_LE(size_, kMaxRunLengthCapacity);
-  return (delta_sizes_[0] << 13) | size_;
+  return (delta_sizes_[0] << 13) | static_cast<uint16_t>(size_);
 }
 
 void TransportFeedback::LastChunk::DecodeRunLength(uint16_t chunk,
                                                    size_t max_count) {
   RTC_DCHECK_EQ(chunk & 0x8000, 0);
   size_ = std::min<size_t>(chunk & 0x1fff, max_count);
-  size_t delta_size = (chunk >> 13) & 0x03;
+  DeltaSize delta_size = (chunk >> 13) & 0x03;
   has_large_delta_ = delta_size >= kLarge;
   all_same_ = true;
   // To make it consistent with Add function, populate delta_sizes_ beyound 1st.
@@ -398,7 +398,7 @@ bool TransportFeedback::Parse(const CommonHeader& packet) {
   ParseCommonFeedback(payload);
 
   base_seq_no_ = ByteReader<uint16_t>::ReadBigEndian(&payload[8]);
-  size_t status_count = ByteReader<uint16_t>::ReadBigEndian(&payload[10]);
+  uint16_t status_count = ByteReader<uint16_t>::ReadBigEndian(&payload[10]);
   base_time_ticks_ = ByteReader<int32_t, 3>::ReadBigEndian(&payload[12]);
   feedback_seq_ = payload[15];
   Clear();