From 8fa21c49eff52b1848ff16483cc3a07af6acc7ca Mon Sep 17 00:00:00 2001
From: eladalon <eladalon@webrtc.org>
Date: Fri, 16 Jun 2017 07:07:47 -0700
Subject: [PATCH] Style fixes in rtcp_packet/

1. To make the files conform to chromium-style guidelines, and stop the compiler from complaing:
1.1. Move constructors out of .h file.
1.2. Move destructors out of .h file.
1.3. Move virtual functions out of .h file.
2. BlockLength() and Create() did not have consistent access modifiers in the various subclasses of RtcpPacket. Change the access level to public throughout.
3. Reorder BlockLength() and Create() where necessary, to reflect the order defined in the parent class (RtcpPacket).

BUG=None

Review-Url: https://codereview.webrtc.org/2937403002
Cr-Commit-Position: refs/heads/master@{#18633}
---
 .../rtp_rtcp/source/rtcp_packet/app.cc        |  9 ++++++
 .../modules/rtp_rtcp/source/rtcp_packet/app.h | 10 +++----
 .../rtp_rtcp/source/rtcp_packet/bye.cc        |  2 ++
 .../modules/rtp_rtcp/source/rtcp_packet/bye.h |  7 ++---
 .../source/rtcp_packet/compound_packet.cc     |  4 +++
 .../source/rtcp_packet/compound_packet.h      |  4 +--
 .../rtp_rtcp/source/rtcp_packet/dlrr.cc       |  6 ++++
 .../rtp_rtcp/source/rtcp_packet/dlrr.h        |  6 ++--
 .../rtcp_packet/extended_jitter_report.cc     |  8 +++++
 .../rtcp_packet/extended_jitter_report.h      | 11 +++----
 .../source/rtcp_packet/extended_reports.cc    |  5 ++++
 .../source/rtcp_packet/extended_reports.h     |  8 ++---
 .../rtp_rtcp/source/rtcp_packet/fir.cc        |  9 ++++++
 .../modules/rtp_rtcp/source/rtcp_packet/fir.h | 11 ++++---
 .../rtp_rtcp/source/rtcp_packet/nack.cc       | 10 +++----
 .../rtp_rtcp/source/rtcp_packet/nack.h        |  5 ++--
 .../rtp_rtcp/source/rtcp_packet/pli.cc        |  4 +++
 .../modules/rtp_rtcp/source/rtcp_packet/pli.h |  8 ++---
 .../rtcp_packet/rapid_resync_request.cc       |  4 +++
 .../source/rtcp_packet/rapid_resync_request.h |  8 ++---
 .../source/rtcp_packet/receiver_report.cc     | 10 +++++++
 .../source/rtcp_packet/receiver_report.h      | 12 +++-----
 .../rtp_rtcp/source/rtcp_packet/remb.cc       |  9 ++++++
 .../rtp_rtcp/source/rtcp_packet/remb.h        | 11 +++----
 .../rtp_rtcp/source/rtcp_packet/sdes.cc       |  4 +++
 .../rtp_rtcp/source/rtcp_packet/sdes.h        |  3 +-
 .../source/rtcp_packet/sender_report.cc       |  7 +++++
 .../source/rtcp_packet/sender_report.h        | 10 ++-----
 .../source/rtcp_packet/target_bitrate.cc      | 30 +++++++++----------
 .../source/rtcp_packet/target_bitrate.h       |  4 +--
 .../rtp_rtcp/source/rtcp_packet/tmmbn.cc      | 10 +++++++
 .../rtp_rtcp/source/rtcp_packet/tmmbn.h       | 12 +++-----
 .../rtp_rtcp/source/rtcp_packet/tmmbr.cc      | 10 +++++++
 .../rtp_rtcp/source/rtcp_packet/tmmbr.h       | 12 +++-----
 .../source/rtcp_packet/transport_feedback.cc  | 10 +++----
 .../source/rtcp_packet/transport_feedback.h   |  5 ++--
 36 files changed, 179 insertions(+), 119 deletions(-)

diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/app.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/app.cc
index 322bf363b4..e9d107811f 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/app.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/app.cc
@@ -32,6 +32,11 @@ constexpr size_t App::kMaxDataSize;
 //    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //  8 |                   application-dependent data                ...
 //    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+App::App() : sub_type_(0), ssrc_(0), name_(0) {}
+
+App::~App() = default;
+
 bool App::Parse(const CommonHeader& packet) {
   RTC_DCHECK_EQ(packet.type(), kPacketType);
   if (packet.payload_size_bytes() < kAppBaseLength) {
@@ -65,6 +70,10 @@ void App::SetData(const uint8_t* data, size_t data_length) {
   data_.SetData(data, data_length);
 }
 
+size_t App::BlockLength() const {
+  return kHeaderLength + kAppBaseLength + data_.size();
+}
+
 bool App::Create(uint8_t* packet,
                  size_t* index,
                  size_t max_length,
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h
index 42a16c7a3a..1261e8456f 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h
@@ -21,8 +21,8 @@ class CommonHeader;
 class App : public RtcpPacket {
  public:
   static constexpr uint8_t kPacketType = 204;
-  App() : sub_type_(0), ssrc_(0), name_(0) {}
-  ~App() override {}
+  App();
+  ~App() override;
 
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
@@ -38,7 +38,8 @@ class App : public RtcpPacket {
   size_t data_size() const { return data_.size(); }
   const uint8_t* data() const { return data_.data(); }
 
- protected:
+  size_t BlockLength() const override;
+
   bool Create(uint8_t* packet,
               size_t* index,
               size_t max_length,
@@ -47,9 +48,6 @@ class App : public RtcpPacket {
  private:
   static constexpr size_t kAppBaseLength = 8;  // Ssrc and Name.
   static constexpr size_t kMaxDataSize = 0xffff * 4 - kAppBaseLength;
-  size_t BlockLength() const override {
-    return kHeaderLength + kAppBaseLength + data_.size();
-  }
 
   uint8_t sub_type_;
   uint32_t ssrc_;
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.cc
index 494c8708f1..965fde282a 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.cc
@@ -34,6 +34,8 @@ constexpr uint8_t Bye::kPacketType;
 //       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 Bye::Bye() : sender_ssrc_(0) {}
 
+Bye::~Bye() = default;
+
 bool Bye::Parse(const CommonHeader& packet) {
   RTC_DCHECK_EQ(packet.type(), kPacketType);
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h
index c3f1cab491..e82f01c43f 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h
@@ -26,7 +26,7 @@ class Bye : public RtcpPacket {
   static constexpr uint8_t kPacketType = 203;
 
   Bye();
-  ~Bye() override {}
+  ~Bye() override;
 
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
@@ -39,7 +39,8 @@ class Bye : public RtcpPacket {
   const std::vector<uint32_t>& csrcs() const { return csrcs_; }
   const std::string& reason() const { return reason_; }
 
- protected:
+  size_t BlockLength() const override;
+
   bool Create(uint8_t* packet,
               size_t* index,
               size_t max_length,
@@ -48,8 +49,6 @@ class Bye : public RtcpPacket {
  private:
   static const int kMaxNumberOfCsrcs = 0x1f - 1;  // First item is sender SSRC.
 
-  size_t BlockLength() const override;
-
   uint32_t sender_ssrc_;
   std::vector<uint32_t> csrcs_;
   std::string reason_;
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet.cc
index eead45d370..d5bbee6c91 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet.cc
@@ -15,6 +15,10 @@
 namespace webrtc {
 namespace rtcp {
 
+CompoundPacket::CompoundPacket() = default;
+
+CompoundPacket::~CompoundPacket() = default;
+
 void CompoundPacket::Append(RtcpPacket* packet) {
   RTC_CHECK(packet);
   appended_packets_.push_back(packet);
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet.h
index 06b67c375c..5bb23dd185 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet.h
@@ -23,8 +23,8 @@ namespace rtcp {
 
 class CompoundPacket : public RtcpPacket {
  public:
-  CompoundPacket() {}
-  ~CompoundPacket() override {}
+  CompoundPacket();
+  ~CompoundPacket() override;
 
   void Append(RtcpPacket* packet);
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr.cc
index 808a4d0d78..80b44d51eb 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr.cc
@@ -33,6 +33,12 @@ namespace rtcp {
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ block
 //  :                               ...                             :   2
 
+Dlrr::Dlrr() = default;
+
+Dlrr::Dlrr(const Dlrr& other) = default;
+
+Dlrr::~Dlrr() = default;
+
 bool Dlrr::Parse(const uint8_t* buffer, uint16_t block_length_32bits) {
   RTC_DCHECK(buffer[0] == kBlockType);
   // kReserved = buffer[1];
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr.h
index c5f5c23bf1..840ca37b6f 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr.h
@@ -33,9 +33,9 @@ class Dlrr {
  public:
   static const uint8_t kBlockType = 5;
 
-  Dlrr() {}
-  Dlrr(const Dlrr& other) = default;
-  ~Dlrr() {}
+  Dlrr();
+  Dlrr(const Dlrr& other);
+  ~Dlrr();
 
   Dlrr& operator=(const Dlrr& other) = default;
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.cc
index c296dbcac9..f7798dc3a1 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.cc
@@ -39,6 +39,10 @@ constexpr uint8_t ExtendedJitterReport::kPacketType;
 //  (inside a compound RTCP packet), and MUST have the same value for RC
 //  (reception report count) as the receiver report.
 
+ExtendedJitterReport::ExtendedJitterReport() = default;
+
+ExtendedJitterReport::~ExtendedJitterReport() = default;
+
 bool ExtendedJitterReport::Parse(const CommonHeader& packet) {
   RTC_DCHECK_EQ(packet.type(), kPacketType);
 
@@ -67,6 +71,10 @@ bool ExtendedJitterReport::SetJitterValues(std::vector<uint32_t> values) {
   return true;
 }
 
+size_t ExtendedJitterReport::BlockLength() const {
+  return kHeaderLength + kJitterSizeBytes * inter_arrival_jitters_.size();
+}
+
 bool ExtendedJitterReport::Create(
     uint8_t* packet,
     size_t* index,
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h
index 2e56e33286..1771e023ca 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h
@@ -24,8 +24,8 @@ class ExtendedJitterReport : public RtcpPacket {
   static constexpr uint8_t kPacketType = 195;
   static constexpr size_t kMaxNumberOfJitterValues = 0x1f;
 
-  ExtendedJitterReport() {}
-  ~ExtendedJitterReport() override {}
+  ExtendedJitterReport();
+  ~ExtendedJitterReport() override;
 
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
@@ -36,7 +36,8 @@ class ExtendedJitterReport : public RtcpPacket {
     return inter_arrival_jitters_;
   }
 
- protected:
+  size_t BlockLength() const override;
+
   bool Create(uint8_t* packet,
               size_t* index,
               size_t max_length,
@@ -45,10 +46,6 @@ class ExtendedJitterReport : public RtcpPacket {
  private:
   static constexpr size_t kJitterSizeBytes = 4;
 
-  size_t BlockLength() const override {
-    return kHeaderLength + kJitterSizeBytes * inter_arrival_jitters_.size();
-  }
-
   std::vector<uint32_t> inter_arrival_jitters_;
 };
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.cc
index 4c02c1ab1a..583083b6ac 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.cc
@@ -118,6 +118,11 @@ void ExtendedReports::SetTargetBitrate(const TargetBitrate& bitrate) {
   target_bitrate_ = rtc::Optional<TargetBitrate>(bitrate);
 }
 
+size_t ExtendedReports::BlockLength() const {
+  return kHeaderLength + kXrBaseLength + RrtrLength() + DlrrLength() +
+         VoipMetricLength() + TargetBitrateLength();
+}
+
 bool ExtendedReports::Create(uint8_t* packet,
                              size_t* index,
                              size_t max_length,
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h
index 09723ef949..cb34f370c5 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h
@@ -52,7 +52,8 @@ class ExtendedReports : public RtcpPacket {
     return target_bitrate_;
   }
 
- protected:
+  size_t BlockLength() const override;
+
   bool Create(uint8_t* packet,
               size_t* index,
               size_t max_length,
@@ -61,11 +62,6 @@ class ExtendedReports : public RtcpPacket {
  private:
   static constexpr size_t kXrBaseLength = 4;
 
-  size_t BlockLength() const override {
-    return kHeaderLength + kXrBaseLength + RrtrLength() + DlrrLength() +
-           VoipMetricLength() + TargetBitrateLength();
-  }
-
   size_t RrtrLength() const { return rrtr_block_ ? Rrtr::kLength : 0; }
   size_t DlrrLength() const { return dlrr_block_.BlockLength(); }
   size_t VoipMetricLength() const {
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.cc
index 7f62e18c9b..069a13c64a 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.cc
@@ -43,6 +43,11 @@ constexpr uint8_t Fir::kFeedbackMessageType;
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //  | Seq nr.       |    Reserved = 0                               |
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+Fir::Fir() = default;
+
+Fir::~Fir() = default;
+
 bool Fir::Parse(const CommonHeader& packet) {
   RTC_DCHECK_EQ(packet.type(), kPacketType);
   RTC_DCHECK_EQ(packet.fmt(), kFeedbackMessageType);
@@ -72,6 +77,10 @@ bool Fir::Parse(const CommonHeader& packet) {
   return true;
 }
 
+size_t Fir::BlockLength() const {
+  return kHeaderLength + kCommonFeedbackLength + kFciLength * items_.size();
+}
+
 bool Fir::Create(uint8_t* packet,
                  size_t* index,
                  size_t max_length,
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.h
index 59f3b61729..8d772d87fa 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.h
@@ -30,8 +30,8 @@ class Fir : public Psfb {
     uint8_t seq_nr;
   };
 
-  Fir() {}
-  ~Fir() override {}
+  Fir();
+  ~Fir() override;
 
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
@@ -41,7 +41,8 @@ class Fir : public Psfb {
   }
   const std::vector<Request>& requests() const { return items_; }
 
- protected:
+  size_t BlockLength() const override;
+
   bool Create(uint8_t* packet,
               size_t* index,
               size_t max_length,
@@ -49,9 +50,7 @@ class Fir : public Psfb {
 
  private:
   static constexpr size_t kFciLength = 8;
-  size_t BlockLength() const override {
-    return kHeaderLength + kCommonFeedbackLength + kFciLength * items_.size();
-  }
+
   // SSRC of media source is not used in FIR packet. Shadow base functions.
   void SetMediaSsrc(uint32_t ssrc);
   uint32_t media_ssrc() const;
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.cc
index 956b16f784..a51764f04b 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.cc
@@ -75,6 +75,11 @@ bool Nack::Parse(const CommonHeader& packet) {
   return true;
 }
 
+size_t Nack::BlockLength() const {
+  return kHeaderLength + kCommonFeedbackLength +
+         packed_.size() * kNackItemLength;
+}
+
 bool Nack::Create(uint8_t* packet,
                   size_t* index,
                   size_t max_length,
@@ -116,11 +121,6 @@ bool Nack::Create(uint8_t* packet,
   return true;
 }
 
-size_t Nack::BlockLength() const {
-  return kHeaderLength + kCommonFeedbackLength +
-         packed_.size() * kNackItemLength;
-}
-
 void Nack::SetPacketIds(const uint16_t* nack_list, size_t length) {
   RTC_DCHECK(nack_list);
   RTC_DCHECK(packet_ids_.empty());
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h
index 65a6593565..2b5acec0ea 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h
@@ -32,14 +32,13 @@ class Nack : public Rtpfb {
   void SetPacketIds(const uint16_t* nack_list, size_t length);
   const std::vector<uint16_t>& packet_ids() const { return packet_ids_; }
 
- protected:
+  size_t BlockLength() const override;
+
   bool Create(uint8_t* packet,
               size_t* index,
               size_t max_length,
               RtcpPacket::PacketReadyCallback* callback) const override;
 
-  size_t BlockLength() const override;
-
  private:
   static constexpr size_t kNackItemLength = 4;
   struct PackedNack {
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.cc
index 7838fccf82..ade6c2a874 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.cc
@@ -49,6 +49,10 @@ bool Pli::Parse(const CommonHeader& packet) {
   return true;
 }
 
+size_t Pli::BlockLength() const {
+  return kHeaderLength + kCommonFeedbackLength;
+}
+
 bool Pli::Create(uint8_t* packet,
                  size_t* index,
                  size_t max_length,
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.h
index 1cfde4f219..c3682bdcaa 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.h
@@ -26,16 +26,12 @@ class Pli : public Psfb {
 
   bool Parse(const CommonHeader& packet);
 
- protected:
+  size_t BlockLength() const override;
+
   bool Create(uint8_t* packet,
               size_t* index,
               size_t max_length,
               RtcpPacket::PacketReadyCallback* callback) const override;
-
- private:
-  size_t BlockLength() const override {
-    return kHeaderLength + kCommonFeedbackLength;
-  }
 };
 
 }  // namespace rtcp
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.cc
index 12a4444cc9..1ec6826e6b 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.cc
@@ -44,6 +44,10 @@ bool RapidResyncRequest::Parse(const CommonHeader& packet) {
   return true;
 }
 
+size_t RapidResyncRequest::BlockLength() const {
+  return kHeaderLength + kCommonFeedbackLength;
+}
+
 bool RapidResyncRequest::Create(
     uint8_t* packet,
     size_t* index,
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.h
index eb45e14f79..ba101a3b09 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.h
@@ -29,16 +29,12 @@ class RapidResyncRequest : public Rtpfb {
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& header);
 
- protected:
+  size_t BlockLength() const override;
+
   bool Create(uint8_t* packet,
               size_t* index,
               size_t max_length,
               RtcpPacket::PacketReadyCallback* callback) const override;
-
- private:
-  size_t BlockLength() const override {
-    return kHeaderLength + kCommonFeedbackLength;
-  }
 };
 }  // namespace rtcp
 }  // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.cc
index 93da4dcd1b..03a9dbd86e 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.cc
@@ -29,6 +29,11 @@ constexpr uint8_t ReceiverReport::kPacketType;
 //  +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
 //  |                         report block(s)                       |
 //  |                            ....                               |
+
+ReceiverReport::ReceiverReport() : sender_ssrc_(0) {}
+
+ReceiverReport::~ReceiverReport() = default;
+
 bool ReceiverReport::Parse(const CommonHeader& packet) {
   RTC_DCHECK_EQ(packet.type(), kPacketType);
 
@@ -55,6 +60,11 @@ bool ReceiverReport::Parse(const CommonHeader& packet) {
   return true;
 }
 
+size_t ReceiverReport::BlockLength() const {
+  return kHeaderLength + kRrBaseLength +
+         report_blocks_.size() * ReportBlock::kLength;
+}
+
 bool ReceiverReport::Create(uint8_t* packet,
                             size_t* index,
                             size_t max_length,
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h
index 09aa0fef3b..2b8b190293 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h
@@ -24,8 +24,8 @@ class CommonHeader;
 class ReceiverReport : public RtcpPacket {
  public:
   static constexpr uint8_t kPacketType = 201;
-  ReceiverReport() : sender_ssrc_(0) {}
-  ~ReceiverReport() override {}
+  ReceiverReport();
+  ~ReceiverReport() override;
 
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
@@ -38,7 +38,8 @@ class ReceiverReport : public RtcpPacket {
     return report_blocks_;
   }
 
- protected:
+  size_t BlockLength() const override;
+
   bool Create(uint8_t* packet,
               size_t* index,
               size_t max_length,
@@ -48,11 +49,6 @@ class ReceiverReport : public RtcpPacket {
   static const size_t kRrBaseLength = 4;
   static const size_t kMaxNumberOfReportBlocks = 0x1F;
 
-  size_t BlockLength() const override {
-    return kHeaderLength + kRrBaseLength +
-           report_blocks_.size() * ReportBlock::kLength;
-  }
-
   uint32_t sender_ssrc_;
   std::vector<ReportBlock> report_blocks_;
 };
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.cc
index ec7b51ad00..c6f89728ff 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.cc
@@ -38,6 +38,11 @@ constexpr uint8_t Remb::kFeedbackMessageType;
 // 16 |   SSRC feedback                                               |
 //    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //    :  ...                                                          :
+
+Remb::Remb() : bitrate_bps_(0) {}
+
+Remb::~Remb() = default;
+
 bool Remb::Parse(const CommonHeader& packet) {
   RTC_DCHECK(packet.type() == kPacketType);
   RTC_DCHECK_EQ(packet.fmt(), kFeedbackMessageType);
@@ -92,6 +97,10 @@ bool Remb::SetSsrcs(std::vector<uint32_t> ssrcs) {
   return true;
 }
 
+size_t Remb::BlockLength() const {
+  return kHeaderLength + kCommonFeedbackLength + (2 + ssrcs_.size()) * 4;
+}
+
 bool Remb::Create(uint8_t* packet,
                   size_t* index,
                   size_t max_length,
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h
index fdcce1082a..42c2a96ce1 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h
@@ -26,8 +26,8 @@ class Remb : public Psfb {
   static constexpr uint8_t kFeedbackMessageType = 15;
   static constexpr size_t kMaxNumberOfSsrcs = 0xff;
 
-  Remb() : bitrate_bps_(0) {}
-  ~Remb() override {}
+  Remb();
+  ~Remb() override;
 
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
@@ -38,16 +38,13 @@ class Remb : public Psfb {
   uint64_t bitrate_bps() const { return bitrate_bps_; }
   const std::vector<uint32_t>& ssrcs() const { return ssrcs_; }
 
- protected:
+  size_t BlockLength() const override;
+
   bool Create(uint8_t* packet,
               size_t* index,
               size_t max_length,
               RtcpPacket::PacketReadyCallback* callback) const override;
 
-  size_t BlockLength() const override {
-    return kHeaderLength + kCommonFeedbackLength + (2 + ssrcs_.size()) * 4;
-  }
-
  private:
   static constexpr uint32_t kUniqueIdentifier = 0x52454D42;  // 'R' 'E' 'M' 'B'.
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.cc
index 9b06b2501e..2e395d7297 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.cc
@@ -155,6 +155,10 @@ bool Sdes::AddCName(uint32_t ssrc, std::string cname) {
   return true;
 }
 
+size_t Sdes::BlockLength() const {
+  return block_length_;
+}
+
 bool Sdes::Create(uint8_t* packet,
                   size_t* index,
                   size_t max_length,
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h
index 46382ac1a5..34885dc00d 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h
@@ -40,9 +40,8 @@ class Sdes : public RtcpPacket {
 
   const std::vector<Chunk>& chunks() const { return chunks_; }
 
-  size_t BlockLength() const override { return block_length_; }
+  size_t BlockLength() const override;
 
- protected:
   bool Create(uint8_t* packet,
               size_t* index,
               size_t max_length,
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.cc
index 312b3f96d1..3cadd431b3 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.cc
@@ -43,6 +43,8 @@ SenderReport::SenderReport()
       sender_packet_count_(0),
       sender_octet_count_(0) {}
 
+SenderReport::~SenderReport() = default;
+
 bool SenderReport::Parse(const CommonHeader& packet) {
   RTC_DCHECK_EQ(packet.type(), kPacketType);
 
@@ -74,6 +76,11 @@ bool SenderReport::Parse(const CommonHeader& packet) {
   return true;
 }
 
+size_t SenderReport::BlockLength() const {
+  return kHeaderLength + kSenderBaseLength +
+         report_blocks_.size() * ReportBlock::kLength;
+}
+
 bool SenderReport::Create(uint8_t* packet,
                           size_t* index,
                           size_t max_length,
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h
index c62e505898..0e39eb52e6 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h
@@ -26,7 +26,7 @@ class SenderReport : public RtcpPacket {
   static constexpr uint8_t kPacketType = 200;
 
   SenderReport();
-  ~SenderReport() override {}
+  ~SenderReport() override;
 
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
@@ -55,7 +55,8 @@ class SenderReport : public RtcpPacket {
     return report_blocks_;
   }
 
- protected:
+  size_t BlockLength() const override;
+
   bool Create(uint8_t* packet,
               size_t* index,
               size_t max_length,
@@ -65,11 +66,6 @@ class SenderReport : public RtcpPacket {
   static const size_t kMaxNumberOfReportBlocks = 0x1f;
   const size_t kSenderBaseLength = 24;
 
-  size_t BlockLength() const override {
-    return kHeaderLength + kSenderBaseLength +
-           report_blocks_.size() * ReportBlock::kLength;
-  }
-
   uint32_t sender_ssrc_;
   NtpTime ntp_;
   uint32_t rtp_timestamp_;
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/target_bitrate.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/target_bitrate.cc
index e3a813a854..913264223f 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/target_bitrate.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/target_bitrate.cc
@@ -65,21 +65,6 @@ TargetBitrate::BitrateItem::BitrateItem(uint8_t spatial_layer,
 TargetBitrate::TargetBitrate() {}
 TargetBitrate::~TargetBitrate() {}
 
-void TargetBitrate::Create(uint8_t* buffer) const {
-  buffer[0] = kBlockType;
-  buffer[1] = 0;  // Reserved.
-  const size_t block_length_words = (BlockLength() / 4) - 1;
-  ByteWriter<uint16_t>::WriteBigEndian(&buffer[2], block_length_words);
-
-  size_t index = kTargetBitrateHeaderSizeBytes;
-  for (const BitrateItem& item : bitrates_) {
-    buffer[index] = (item.spatial_layer << 4) | item.temporal_layer;
-    ByteWriter<uint32_t, 3>::WriteBigEndian(&buffer[index + 1],
-                                            item.target_bitrate_kbps);
-    index += kBitrateItemSizeBytes;
-  }
-}
-
 bool TargetBitrate::Parse(const uint8_t* block, uint16_t block_length) {
   if (block_length < 1) {
     LOG(LS_WARNING)
@@ -130,5 +115,20 @@ size_t TargetBitrate::BlockLength() const {
          bitrates_.size() * kBitrateItemSizeBytes;
 }
 
+void TargetBitrate::Create(uint8_t* buffer) const {
+  buffer[0] = kBlockType;
+  buffer[1] = 0;  // Reserved.
+  const size_t block_length_words = (BlockLength() / 4) - 1;
+  ByteWriter<uint16_t>::WriteBigEndian(&buffer[2], block_length_words);
+
+  size_t index = kTargetBitrateHeaderSizeBytes;
+  for (const BitrateItem& item : bitrates_) {
+    buffer[index] = (item.spatial_layer << 4) | item.temporal_layer;
+    ByteWriter<uint32_t, 3>::WriteBigEndian(&buffer[index + 1],
+                                            item.target_bitrate_kbps);
+    index += kBitrateItemSizeBytes;
+  }
+}
+
 }  // namespace rtcp
 }  // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/target_bitrate.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/target_bitrate.h
index 013c222f8e..d3f672a192 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/target_bitrate.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/target_bitrate.h
@@ -47,10 +47,10 @@ class TargetBitrate {
 
   bool Parse(const uint8_t* block, uint16_t block_length);
 
-  void Create(uint8_t* buffer) const;
-
   size_t BlockLength() const;
 
+  void Create(uint8_t* buffer) const;
+
  private:
   std::vector<BitrateItem> bitrates_;
 };
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.cc
index 702afd8a8c..d9c3227ddb 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.cc
@@ -42,6 +42,11 @@ constexpr uint8_t Tmmbn::kFeedbackMessageType;
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //   | MxTBR Exp |  MxTBR Mantissa                 |Measured Overhead|
 //   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+Tmmbn::Tmmbn() = default;
+
+Tmmbn::~Tmmbn() = default;
+
 bool Tmmbn::Parse(const CommonHeader& packet) {
   RTC_DCHECK_EQ(packet.type(), kPacketType);
   RTC_DCHECK_EQ(packet.fmt(), kFeedbackMessageType);
@@ -74,6 +79,11 @@ void Tmmbn::AddTmmbr(const TmmbItem& item) {
   items_.push_back(item);
 }
 
+size_t Tmmbn::BlockLength() const {
+  return kHeaderLength + kCommonFeedbackLength +
+         TmmbItem::kLength * items_.size();
+}
+
 bool Tmmbn::Create(uint8_t* packet,
                    size_t* index,
                    size_t max_length,
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.h
index a02aad6422..8b32366e24 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.h
@@ -27,8 +27,8 @@ class Tmmbn : public Rtpfb {
  public:
   static constexpr uint8_t kFeedbackMessageType = 4;
 
-  Tmmbn() {}
-  ~Tmmbn() override {}
+  Tmmbn();
+  ~Tmmbn() override;
 
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
@@ -37,18 +37,14 @@ class Tmmbn : public Rtpfb {
 
   const std::vector<TmmbItem>& items() const { return items_; }
 
- protected:
+  size_t BlockLength() const override;
+
   bool Create(uint8_t* packet,
               size_t* index,
               size_t max_length,
               RtcpPacket::PacketReadyCallback* callback) const override;
 
  private:
-  size_t BlockLength() const override {
-    return kHeaderLength + kCommonFeedbackLength +
-           TmmbItem::kLength * items_.size();
-  }
-
   // Media ssrc is unused, shadow base class setter and getter.
   void SetMediaSsrc(uint32_t ssrc);
   uint32_t media_ssrc() const;
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.cc
index 0ba131187b..fd0719ea5e 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.cc
@@ -43,6 +43,11 @@ constexpr uint8_t Tmmbr::kFeedbackMessageType;
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //  | MxTBR Exp |  MxTBR Mantissa                 |Measured Overhead|
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+Tmmbr::Tmmbr() = default;
+
+Tmmbr::~Tmmbr() = default;
+
 bool Tmmbr::Parse(const CommonHeader& packet) {
   RTC_DCHECK_EQ(packet.type(), kPacketType);
   RTC_DCHECK_EQ(packet.fmt(), kFeedbackMessageType);
@@ -75,6 +80,11 @@ void Tmmbr::AddTmmbr(const TmmbItem& item) {
   items_.push_back(item);
 }
 
+size_t Tmmbr::BlockLength() const {
+  return kHeaderLength + kCommonFeedbackLength +
+         TmmbItem::kLength * items_.size();
+}
+
 bool Tmmbr::Create(uint8_t* packet,
                    size_t* index,
                    size_t max_length,
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h
index 2915c9d4bc..4d1bf11e06 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h
@@ -27,8 +27,8 @@ class Tmmbr : public Rtpfb {
  public:
   static constexpr uint8_t kFeedbackMessageType = 3;
 
-  Tmmbr() {}
-  ~Tmmbr() override {}
+  Tmmbr();
+  ~Tmmbr() override;
 
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
@@ -37,18 +37,14 @@ class Tmmbr : public Rtpfb {
 
   const std::vector<TmmbItem>& requests() const { return items_; }
 
- protected:
+  size_t BlockLength() const override;
+
   bool Create(uint8_t* packet,
               size_t* index,
               size_t max_length,
               RtcpPacket::PacketReadyCallback* callback) const override;
 
  private:
-  size_t BlockLength() const override {
-    return kHeaderLength + kCommonFeedbackLength +
-           TmmbItem::kLength * items_.size();
-  }
-
   // Media ssrc is unused, shadow base class setter.
   void SetMediaSsrc(uint32_t ssrc);
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc
index ec7c6163b3..796577cc59 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc
@@ -545,6 +545,11 @@ bool TransportFeedback::IsConsistent() const {
   return true;
 }
 
+size_t TransportFeedback::BlockLength() const {
+  // Round size_bytes_ up to multiple of 32bits.
+  return (size_bytes_ + 3) & (~static_cast<size_t>(3));
+}
+
 // Serialize packet.
 bool TransportFeedback::Create(uint8_t* packet,
                                size_t* position,
@@ -602,11 +607,6 @@ bool TransportFeedback::Create(uint8_t* packet,
   return true;
 }
 
-size_t TransportFeedback::BlockLength() const {
-  // Round size_bytes_ up to multiple of 32bits.
-  return (size_bytes_ + 3) & (~static_cast<size_t>(3));
-}
-
 void TransportFeedback::Clear() {
   num_seq_no_ = 0;
   last_timestamp_us_ = GetBaseTimeUs();
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h b/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h
index 25f1111914..35fe90bb88 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h
@@ -69,14 +69,13 @@ class TransportFeedback : public Rtpfb {
   // This function is for tests.
   bool IsConsistent() const;
 
- protected:
+  size_t BlockLength() const override;
+
   bool Create(uint8_t* packet,
               size_t* position,
               size_t max_length,
               PacketReadyCallback* callback) const override;
 
-  size_t BlockLength() const override;
-
  private:
   // Size in bytes of a delta time in rtcp packet.
   // Valid values are 0 (packet wasn't received), 1 or 2.