From ba6f7be234cc31c2b9da791b58af77843fe048a6 Mon Sep 17 00:00:00 2001
From: Danil Chapovalov <danilchap@webrtc.org>
Date: Fri, 2 Sep 2016 18:29:10 +0200
Subject: [PATCH] Test RtcpParser rewritten to use rtcp packet classes instead
 of rtcp_utility

BUG=webrtc:5260
R=sprang@webrtc.org, stefan@webrtc.org

Review URL: https://codereview.webrtc.org/2070673002 .

Cr-Commit-Position: refs/heads/master@{#14050}
---
 .../rtcp_packet/compound_packet_unittest.cc   |  12 +-
 .../rtp_rtcp/source/rtcp_sender_unittest.cc   | 250 +++---
 .../rtp_rtcp/source/rtp_rtcp_impl_unittest.cc |   9 +-
 webrtc/test/rtcp_packet_parser.cc             | 187 ++---
 webrtc/test/rtcp_packet_parser.h              | 755 ++----------------
 webrtc/video/end_to_end_tests.cc              |   8 +-
 6 files changed, 288 insertions(+), 933 deletions(-)

diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet_unittest.cc
index f341bad9df..94686fb275 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet_unittest.cc
@@ -47,8 +47,8 @@ TEST(RtcpCompoundPacketTest, AppendPacket) {
   RtcpPacketParser parser;
   parser.Parse(packet.data(), packet.size());
   EXPECT_EQ(1, parser.receiver_report()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser.receiver_report()->Ssrc());
-  EXPECT_EQ(1, parser.report_block()->num_packets());
+  EXPECT_EQ(kSenderSsrc, parser.receiver_report()->sender_ssrc());
+  EXPECT_EQ(1u, parser.receiver_report()->report_blocks().size());
   EXPECT_EQ(1, parser.fir()->num_packets());
 }
 
@@ -75,7 +75,7 @@ TEST(RtcpCompoundPacketTest, AppendPacketWithOwnAppendedPacket) {
   parser.Parse(packet.data(), packet.size());
   EXPECT_EQ(1, parser.sender_report()->num_packets());
   EXPECT_EQ(1, parser.receiver_report()->num_packets());
-  EXPECT_EQ(1, parser.report_block()->num_packets());
+  EXPECT_EQ(1u, parser.receiver_report()->report_blocks().size());
   EXPECT_EQ(1, parser.bye()->num_packets());
   EXPECT_EQ(1, parser.fir()->num_packets());
 }
@@ -101,7 +101,7 @@ TEST(RtcpCompoundPacketTest, BuildWithInputBuffer) {
       RtcpPacketParser parser;
       parser.Parse(data, length);
       EXPECT_EQ(1, parser.receiver_report()->num_packets());
-      EXPECT_EQ(1, parser.report_block()->num_packets());
+      EXPECT_EQ(1u, parser.receiver_report()->report_blocks().size());
       EXPECT_EQ(1, parser.fir()->num_packets());
       ++packets_created_;
     }
@@ -136,12 +136,12 @@ TEST(RtcpCompoundPacketTest, BuildWithTooSmallBuffer_FragmentedSend) {
       switch (packets_created_++) {
         case 0:
           EXPECT_EQ(1, parser.receiver_report()->num_packets());
-          EXPECT_EQ(1, parser.report_block()->num_packets());
+          EXPECT_EQ(1U, parser.receiver_report()->report_blocks().size());
           EXPECT_EQ(0, parser.fir()->num_packets());
           break;
         case 1:
           EXPECT_EQ(0, parser.receiver_report()->num_packets());
-          EXPECT_EQ(0, parser.report_block()->num_packets());
+          EXPECT_EQ(0U, parser.receiver_report()->report_blocks().size());
           EXPECT_EQ(1, parser.fir()->num_packets());
           break;
         default:
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
index 381908d5fe..ac7facea02 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
@@ -208,7 +208,7 @@ class TestTransport : public Transport,
     return false;
   }
   bool SendRtcp(const uint8_t* data, size_t len) override {
-    parser_.Parse(static_cast<const uint8_t*>(data), len);
+    parser_.Parse(data, len);
     return true;
   }
   int OnReceivedPayloadData(const uint8_t* payload_data,
@@ -301,14 +301,14 @@ TEST_F(RtcpSenderTest, SendSr) {
   clock_.CurrentNtp(ntp_secs, ntp_frac);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr));
   EXPECT_EQ(1, parser()->sender_report()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser()->sender_report()->Ssrc());
-  EXPECT_EQ(ntp_secs, parser()->sender_report()->NtpSec());
-  EXPECT_EQ(ntp_frac, parser()->sender_report()->NtpFrac());
-  EXPECT_EQ(kPacketCount, parser()->sender_report()->PacketCount());
-  EXPECT_EQ(kOctetCount, parser()->sender_report()->OctetCount());
+  EXPECT_EQ(kSenderSsrc, parser()->sender_report()->sender_ssrc());
+  EXPECT_EQ(ntp_secs, parser()->sender_report()->ntp().seconds());
+  EXPECT_EQ(ntp_frac, parser()->sender_report()->ntp().fractions());
+  EXPECT_EQ(kPacketCount, parser()->sender_report()->sender_packet_count());
+  EXPECT_EQ(kOctetCount, parser()->sender_report()->sender_octet_count());
   EXPECT_EQ(kStartRtpTimestamp + kRtpTimestamp,
-            parser()->sender_report()->RtpTimestamp());
-  EXPECT_EQ(0, parser()->report_block()->num_packets());
+            parser()->sender_report()->rtp_timestamp());
+  EXPECT_EQ(0U, parser()->sender_report()->report_blocks().size());
 }
 
 TEST_F(RtcpSenderTest, DoNotSendSrBeforeRtp) {
@@ -347,8 +347,8 @@ TEST_F(RtcpSenderTest, SendRr) {
   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr));
   EXPECT_EQ(1, parser()->receiver_report()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->Ssrc());
-  EXPECT_EQ(0, parser()->report_block()->num_packets());
+  EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->sender_ssrc());
+  EXPECT_EQ(0U, parser()->receiver_report()->report_blocks().size());
 }
 
 TEST_F(RtcpSenderTest, SendRrWithOneReportBlock) {
@@ -357,12 +357,13 @@ TEST_F(RtcpSenderTest, SendRrWithOneReportBlock) {
   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr));
   EXPECT_EQ(1, parser()->receiver_report()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->Ssrc());
-  EXPECT_EQ(1, parser()->report_block()->num_packets());
-  EXPECT_EQ(kRemoteSsrc, parser()->report_block()->Ssrc());
-  EXPECT_EQ(0U, parser()->report_block()->FractionLost());
-  EXPECT_EQ(0U, parser()->report_block()->CumPacketLost());
-  EXPECT_EQ(kSeqNum, parser()->report_block()->ExtHighestSeqNum());
+  EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->sender_ssrc());
+  ASSERT_EQ(1U, parser()->receiver_report()->report_blocks().size());
+  const rtcp::ReportBlock& rb = parser()->receiver_report()->report_blocks()[0];
+  EXPECT_EQ(kRemoteSsrc, rb.source_ssrc());
+  EXPECT_EQ(0U, rb.fraction_lost());
+  EXPECT_EQ(0U, rb.cumulative_lost());
+  EXPECT_EQ(kSeqNum, rb.extended_high_seq_num());
 }
 
 TEST_F(RtcpSenderTest, SendRrWithTwoReportBlocks) {
@@ -372,10 +373,12 @@ TEST_F(RtcpSenderTest, SendRrWithTwoReportBlocks) {
   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr));
   EXPECT_EQ(1, parser()->receiver_report()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->Ssrc());
-  EXPECT_EQ(2, parser()->report_block()->num_packets());
-  EXPECT_EQ(1, parser()->report_blocks_per_ssrc(kRemoteSsrc));
-  EXPECT_EQ(1, parser()->report_blocks_per_ssrc(kRemoteSsrc + 1));
+  EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->sender_ssrc());
+  EXPECT_EQ(2U, parser()->receiver_report()->report_blocks().size());
+  EXPECT_EQ(kRemoteSsrc,
+            parser()->receiver_report()->report_blocks()[0].source_ssrc());
+  EXPECT_EQ(kRemoteSsrc + 1,
+            parser()->receiver_report()->report_blocks()[1].source_ssrc());
 }
 
 TEST_F(RtcpSenderTest, SendSdes) {
@@ -383,9 +386,9 @@ TEST_F(RtcpSenderTest, SendSdes) {
   EXPECT_EQ(0, rtcp_sender_->SetCNAME("alice@host"));
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSdes));
   EXPECT_EQ(1, parser()->sdes()->num_packets());
-  EXPECT_EQ(1, parser()->sdes_chunk()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser()->sdes_chunk()->Ssrc());
-  EXPECT_EQ("alice@host", parser()->sdes_chunk()->Cname());
+  EXPECT_EQ(1U, parser()->sdes()->chunks().size());
+  EXPECT_EQ(kSenderSsrc, parser()->sdes()->chunks()[0].ssrc);
+  EXPECT_EQ("alice@host", parser()->sdes()->chunks()[0].cname);
 }
 
 TEST_F(RtcpSenderTest, SdesIncludedInCompoundPacket) {
@@ -394,14 +397,14 @@ TEST_F(RtcpSenderTest, SdesIncludedInCompoundPacket) {
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
   EXPECT_EQ(1, parser()->receiver_report()->num_packets());
   EXPECT_EQ(1, parser()->sdes()->num_packets());
-  EXPECT_EQ(1, parser()->sdes_chunk()->num_packets());
+  EXPECT_EQ(1U, parser()->sdes()->chunks().size());
 }
 
 TEST_F(RtcpSenderTest, SendBye) {
   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpBye));
   EXPECT_EQ(1, parser()->bye()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser()->bye()->Ssrc());
+  EXPECT_EQ(kSenderSsrc, parser()->bye()->sender_ssrc());
 }
 
 TEST_F(RtcpSenderTest, StopSendingTriggersBye) {
@@ -409,7 +412,7 @@ TEST_F(RtcpSenderTest, StopSendingTriggersBye) {
   EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true));
   EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false));
   EXPECT_EQ(1, parser()->bye()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser()->bye()->Ssrc());
+  EXPECT_EQ(kSenderSsrc, parser()->bye()->sender_ssrc());
 }
 
 TEST_F(RtcpSenderTest, SendApp) {
@@ -419,19 +422,15 @@ TEST_F(RtcpSenderTest, SendApp) {
   name += 'm' << 8;
   name += 'e';
   const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'};
-  const uint16_t kDataLength = sizeof(kData) / sizeof(kData[0]);
   EXPECT_EQ(0, rtcp_sender_->SetApplicationSpecificData(kSubType, name, kData,
-                                                        kDataLength));
+                                                        sizeof(kData)));
   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpApp));
   EXPECT_EQ(1, parser()->app()->num_packets());
-  EXPECT_EQ(kSubType, parser()->app()->SubType());
-  EXPECT_EQ(name, parser()->app()->Name());
-  EXPECT_EQ(1, parser()->app_item()->num_packets());
-  EXPECT_EQ(kDataLength, parser()->app_item()->DataLength());
-  EXPECT_EQ(0, strncmp(reinterpret_cast<const char*>(kData),
-      reinterpret_cast<const char*>(parser()->app_item()->Data()),
-      parser()->app_item()->DataLength()));
+  EXPECT_EQ(kSubType, parser()->app()->sub_type());
+  EXPECT_EQ(name, parser()->app()->name());
+  EXPECT_EQ(sizeof(kData), parser()->app()->data_size());
+  EXPECT_EQ(0, memcmp(kData, parser()->app()->data(), sizeof(kData)));
 }
 
 TEST_F(RtcpSenderTest, SendEmptyApp) {
@@ -444,9 +443,9 @@ TEST_F(RtcpSenderTest, SendEmptyApp) {
   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpApp));
   EXPECT_EQ(1, parser()->app()->num_packets());
-  EXPECT_EQ(kSubType, parser()->app()->SubType());
-  EXPECT_EQ(kName, parser()->app()->Name());
-  EXPECT_EQ(0, parser()->app_item()->num_packets());
+  EXPECT_EQ(kSubType, parser()->app()->sub_type());
+  EXPECT_EQ(kName, parser()->app()->name());
+  EXPECT_EQ(0U, parser()->app()->data_size());
 }
 
 TEST_F(RtcpSenderTest, SetInvalidApplicationSpecificData) {
@@ -460,37 +459,35 @@ TEST_F(RtcpSenderTest, SendFirNonRepeat) {
   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpFir));
   EXPECT_EQ(1, parser()->fir()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser()->fir()->Ssrc());
-  EXPECT_EQ(1, parser()->fir_item()->num_packets());
-  EXPECT_EQ(kRemoteSsrc, parser()->fir_item()->Ssrc());
-  uint8_t seq = parser()->fir_item()->SeqNum();
+  EXPECT_EQ(kSenderSsrc, parser()->fir()->sender_ssrc());
+  EXPECT_EQ(1U, parser()->fir()->requests().size());
+  EXPECT_EQ(kRemoteSsrc, parser()->fir()->requests()[0].ssrc);
+  uint8_t seq = parser()->fir()->requests()[0].seq_nr;
   // Sends non-repeat FIR as default.
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpFir));
   EXPECT_EQ(2, parser()->fir()->num_packets());
-  EXPECT_EQ(2, parser()->fir_item()->num_packets());
-  EXPECT_EQ(seq + 1, parser()->fir_item()->SeqNum());
+  EXPECT_EQ(seq + 1, parser()->fir()->requests()[0].seq_nr);
 }
 
 TEST_F(RtcpSenderTest, SendFirRepeat) {
   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpFir));
   EXPECT_EQ(1, parser()->fir()->num_packets());
-  EXPECT_EQ(1, parser()->fir_item()->num_packets());
-  uint8_t seq = parser()->fir_item()->SeqNum();
+  EXPECT_EQ(1U, parser()->fir()->requests().size());
+  uint8_t seq = parser()->fir()->requests()[0].seq_nr;
   const bool kRepeat = true;
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpFir, 0, nullptr,
                                       kRepeat));
   EXPECT_EQ(2, parser()->fir()->num_packets());
-  EXPECT_EQ(2, parser()->fir_item()->num_packets());
-  EXPECT_EQ(seq, parser()->fir_item()->SeqNum());
+  EXPECT_EQ(seq, parser()->fir()->requests()[0].seq_nr);
 }
 
 TEST_F(RtcpSenderTest, SendPli) {
   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli));
   EXPECT_EQ(1, parser()->pli()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser()->pli()->Ssrc());
-  EXPECT_EQ(kRemoteSsrc, parser()->pli()->MediaSsrc());
+  EXPECT_EQ(kSenderSsrc, parser()->pli()->sender_ssrc());
+  EXPECT_EQ(kRemoteSsrc, parser()->pli()->media_ssrc());
 }
 
 TEST_F(RtcpSenderTest, SendRpsi) {
@@ -502,8 +499,8 @@ TEST_F(RtcpSenderTest, SendRpsi) {
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpRpsi, 0, nullptr,
                                       false, kPictureId));
   EXPECT_EQ(1, parser()->rpsi()->num_packets());
-  EXPECT_EQ(kPayloadType, parser()->rpsi()->PayloadType());
-  EXPECT_EQ(kPictureId, parser()->rpsi()->PictureId());
+  EXPECT_EQ(kPayloadType, parser()->rpsi()->payload_type());
+  EXPECT_EQ(kPictureId, parser()->rpsi()->picture_id());
 }
 
 TEST_F(RtcpSenderTest, SendSli) {
@@ -514,12 +511,12 @@ TEST_F(RtcpSenderTest, SendSli) {
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSli, 0, nullptr,
                                       false, kPictureId));
   EXPECT_EQ(1, parser()->sli()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser()->sli()->Ssrc());
-  EXPECT_EQ(kRemoteSsrc, parser()->sli()->MediaSsrc());
-  EXPECT_EQ(1, parser()->sli_item()->num_packets());
-  EXPECT_EQ(kFirstMb, parser()->sli_item()->FirstMb());
-  EXPECT_EQ(kNumberOfMb, parser()->sli_item()->NumberOfMb());
-  EXPECT_EQ(kPictureId, parser()->sli_item()->PictureId());
+  EXPECT_EQ(kSenderSsrc, parser()->sli()->sender_ssrc());
+  EXPECT_EQ(kRemoteSsrc, parser()->sli()->media_ssrc());
+  EXPECT_EQ(1U, parser()->sli()->macroblocks().size());
+  EXPECT_EQ(kFirstMb, parser()->sli()->macroblocks()[0].first());
+  EXPECT_EQ(kNumberOfMb, parser()->sli()->macroblocks()[0].number());
+  EXPECT_EQ(kPictureId, parser()->sli()->macroblocks()[0].picture_id());
 }
 
 TEST_F(RtcpSenderTest, SendNack) {
@@ -529,25 +526,23 @@ TEST_F(RtcpSenderTest, SendNack) {
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpNack, kListLength,
                                       kList));
   EXPECT_EQ(1, parser()->nack()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser()->nack()->Ssrc());
-  EXPECT_EQ(kRemoteSsrc, parser()->nack()->MediaSsrc());
-  EXPECT_EQ(1, parser()->nack_item()->num_packets());
-  EXPECT_THAT(parser()->nack_item()->last_nack_list(), ElementsAre(0, 1, 16));
+  EXPECT_EQ(kSenderSsrc, parser()->nack()->sender_ssrc());
+  EXPECT_EQ(kRemoteSsrc, parser()->nack()->media_ssrc());
+  EXPECT_THAT(parser()->nack()->packet_ids(), ElementsAre(0, 1, 16));
 }
 
 TEST_F(RtcpSenderTest, SendRemb) {
-  const int kBitrate = 261011;
+  const uint64_t kBitrate = 261011;
   std::vector<uint32_t> ssrcs;
   ssrcs.push_back(kRemoteSsrc);
   ssrcs.push_back(kRemoteSsrc + 1);
   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
   rtcp_sender_->SetREMBData(kBitrate, ssrcs);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRemb));
-  EXPECT_EQ(1, parser()->psfb_app()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser()->psfb_app()->Ssrc());
-  EXPECT_EQ(1, parser()->remb_item()->num_packets());
-  EXPECT_EQ(kBitrate, parser()->remb_item()->last_bitrate_bps());
-  EXPECT_THAT(parser()->remb_item()->last_ssrc_list(),
+  EXPECT_EQ(1, parser()->remb()->num_packets());
+  EXPECT_EQ(kSenderSsrc, parser()->remb()->sender_ssrc());
+  EXPECT_EQ(kBitrate, parser()->remb()->bitrate_bps());
+  EXPECT_THAT(parser()->remb()->ssrcs(),
               ElementsAre(kRemoteSsrc, kRemoteSsrc + 1));
 }
 
@@ -560,12 +555,10 @@ TEST_F(RtcpSenderTest, RembIncludedInCompoundPacketIfEnabled) {
   EXPECT_TRUE(rtcp_sender_->REMB());
   rtcp_sender_->SetREMBData(kBitrate, ssrcs);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
-  EXPECT_EQ(1, parser()->psfb_app()->num_packets());
-  EXPECT_EQ(1, parser()->remb_item()->num_packets());
+  EXPECT_EQ(1, parser()->remb()->num_packets());
   // REMB should be included in each compound packet.
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
-  EXPECT_EQ(2, parser()->psfb_app()->num_packets());
-  EXPECT_EQ(2, parser()->remb_item()->num_packets());
+  EXPECT_EQ(2, parser()->remb()->num_packets());
 }
 
 TEST_F(RtcpSenderTest, RembNotIncludedInCompoundPacketIfNotEnabled) {
@@ -576,7 +569,7 @@ TEST_F(RtcpSenderTest, RembNotIncludedInCompoundPacketIfNotEnabled) {
   rtcp_sender_->SetREMBData(kBitrate, ssrcs);
   EXPECT_FALSE(rtcp_sender_->REMB());
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
-  EXPECT_EQ(0, parser()->psfb_app()->num_packets());
+  EXPECT_EQ(0, parser()->remb()->num_packets());
 }
 
 TEST_F(RtcpSenderTest, SendXrWithVoipMetric) {
@@ -604,30 +597,30 @@ TEST_F(RtcpSenderTest, SendXrWithVoipMetric) {
   metric.JBabsMax = 0x7777;
   EXPECT_EQ(0, rtcp_sender_->SetRTCPVoIPMetrics(&metric));
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpXrVoipMetric));
-  EXPECT_EQ(1, parser()->xr_header()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser()->xr_header()->Ssrc());
-  EXPECT_EQ(1, parser()->voip_metric()->num_packets());
-  EXPECT_EQ(kRemoteSsrc, parser()->voip_metric()->Ssrc());
-  EXPECT_EQ(metric.lossRate, parser()->voip_metric()->LossRate());
-  EXPECT_EQ(metric.discardRate, parser()->voip_metric()->DiscardRate());
-  EXPECT_EQ(metric.burstDensity, parser()->voip_metric()->BurstDensity());
-  EXPECT_EQ(metric.gapDensity, parser()->voip_metric()->GapDensity());
-  EXPECT_EQ(metric.burstDuration, parser()->voip_metric()->BurstDuration());
-  EXPECT_EQ(metric.gapDuration, parser()->voip_metric()->GapDuration());
-  EXPECT_EQ(metric.roundTripDelay, parser()->voip_metric()->RoundTripDelay());
-  EXPECT_EQ(metric.endSystemDelay, parser()->voip_metric()->EndSystemDelay());
-  EXPECT_EQ(metric.signalLevel, parser()->voip_metric()->SignalLevel());
-  EXPECT_EQ(metric.noiseLevel, parser()->voip_metric()->NoiseLevel());
-  EXPECT_EQ(metric.RERL, parser()->voip_metric()->Rerl());
-  EXPECT_EQ(metric.Gmin, parser()->voip_metric()->Gmin());
-  EXPECT_EQ(metric.Rfactor, parser()->voip_metric()->Rfactor());
-  EXPECT_EQ(metric.extRfactor, parser()->voip_metric()->ExtRfactor());
-  EXPECT_EQ(metric.MOSLQ, parser()->voip_metric()->MosLq());
-  EXPECT_EQ(metric.MOSCQ, parser()->voip_metric()->MosCq());
-  EXPECT_EQ(metric.RXconfig, parser()->voip_metric()->RxConfig());
-  EXPECT_EQ(metric.JBnominal, parser()->voip_metric()->JbNominal());
-  EXPECT_EQ(metric.JBmax, parser()->voip_metric()->JbMax());
-  EXPECT_EQ(metric.JBabsMax, parser()->voip_metric()->JbAbsMax());
+  EXPECT_EQ(1, parser()->xr()->num_packets());
+  EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc());
+  EXPECT_EQ(1U, parser()->xr()->voip_metrics().size());
+  EXPECT_EQ(kRemoteSsrc, parser()->xr()->voip_metrics()[0].ssrc());
+  EXPECT_EQ(metric.lossRate, parser()->voip_metric()->lossRate);
+  EXPECT_EQ(metric.discardRate, parser()->voip_metric()->discardRate);
+  EXPECT_EQ(metric.burstDensity, parser()->voip_metric()->burstDensity);
+  EXPECT_EQ(metric.gapDensity, parser()->voip_metric()->gapDensity);
+  EXPECT_EQ(metric.burstDuration, parser()->voip_metric()->burstDuration);
+  EXPECT_EQ(metric.gapDuration, parser()->voip_metric()->gapDuration);
+  EXPECT_EQ(metric.roundTripDelay, parser()->voip_metric()->roundTripDelay);
+  EXPECT_EQ(metric.endSystemDelay, parser()->voip_metric()->endSystemDelay);
+  EXPECT_EQ(metric.signalLevel, parser()->voip_metric()->signalLevel);
+  EXPECT_EQ(metric.noiseLevel, parser()->voip_metric()->noiseLevel);
+  EXPECT_EQ(metric.RERL, parser()->voip_metric()->RERL);
+  EXPECT_EQ(metric.Gmin, parser()->voip_metric()->Gmin);
+  EXPECT_EQ(metric.Rfactor, parser()->voip_metric()->Rfactor);
+  EXPECT_EQ(metric.extRfactor, parser()->voip_metric()->extRfactor);
+  EXPECT_EQ(metric.MOSLQ, parser()->voip_metric()->MOSLQ);
+  EXPECT_EQ(metric.MOSCQ, parser()->voip_metric()->MOSCQ);
+  EXPECT_EQ(metric.RXconfig, parser()->voip_metric()->RXconfig);
+  EXPECT_EQ(metric.JBnominal, parser()->voip_metric()->JBnominal);
+  EXPECT_EQ(metric.JBmax, parser()->voip_metric()->JBmax);
+  EXPECT_EQ(metric.JBabsMax, parser()->voip_metric()->JBabsMax);
 }
 
 TEST_F(RtcpSenderTest, SendXrWithDlrr) {
@@ -640,14 +633,16 @@ TEST_F(RtcpSenderTest, SendXrWithDlrr) {
   last_xr_rr.delaySinceLastRR = 0x33333333;
   feedback_state.last_xr_rr = last_xr_rr;
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport));
-  EXPECT_EQ(1, parser()->xr_header()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser()->xr_header()->Ssrc());
-  EXPECT_EQ(1, parser()->dlrr()->num_packets());
-  EXPECT_EQ(1, parser()->dlrr_items()->num_packets());
-  EXPECT_EQ(last_xr_rr.sourceSSRC, parser()->dlrr_items()->Ssrc(0));
-  EXPECT_EQ(last_xr_rr.lastRR, parser()->dlrr_items()->LastRr(0));
+  EXPECT_EQ(1, parser()->xr()->num_packets());
+  EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc());
+  EXPECT_EQ(1U, parser()->xr()->dlrrs().size());
+  EXPECT_EQ(1U, parser()->xr()->dlrrs()[0].sub_blocks().size());
+  EXPECT_EQ(last_xr_rr.sourceSSRC,
+            parser()->xr()->dlrrs()[0].sub_blocks()[0].ssrc);
+  EXPECT_EQ(last_xr_rr.lastRR,
+            parser()->xr()->dlrrs()[0].sub_blocks()[0].last_rr);
   EXPECT_EQ(last_xr_rr.delaySinceLastRR,
-            parser()->dlrr_items()->DelayLastRr(0));
+            parser()->xr()->dlrrs()[0].sub_blocks()[0].delay_since_last_rr);
 }
 
 TEST_F(RtcpSenderTest, SendXrWithRrtr) {
@@ -658,12 +653,12 @@ TEST_F(RtcpSenderTest, SendXrWithRrtr) {
   uint32_t ntp_frac;
   clock_.CurrentNtp(ntp_secs, ntp_frac);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
-  EXPECT_EQ(1, parser()->xr_header()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser()->xr_header()->Ssrc());
-  EXPECT_EQ(0, parser()->dlrr()->num_packets());
-  EXPECT_EQ(1, parser()->rrtr()->num_packets());
-  EXPECT_EQ(ntp_secs, parser()->rrtr()->NtpSec());
-  EXPECT_EQ(ntp_frac, parser()->rrtr()->NtpFrac());
+  EXPECT_EQ(1, parser()->xr()->num_packets());
+  EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc());
+  EXPECT_EQ(0U, parser()->xr()->dlrrs().size());
+  EXPECT_EQ(1U, parser()->xr()->rrtrs().size());
+  EXPECT_EQ(ntp_secs, parser()->xr()->rrtrs()[0].ntp().seconds());
+  EXPECT_EQ(ntp_frac, parser()->xr()->rrtrs()[0].ntp().fractions());
 }
 
 TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfSending) {
@@ -671,8 +666,7 @@ TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfSending) {
   EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true));
   rtcp_sender_->SendRtcpXrReceiverReferenceTime(true);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
-  EXPECT_EQ(0, parser()->xr_header()->num_packets());
-  EXPECT_EQ(0, parser()->rrtr()->num_packets());
+  EXPECT_EQ(0, parser()->xr()->num_packets());
 }
 
 TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfNotEnabled) {
@@ -680,8 +674,7 @@ TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfNotEnabled) {
   EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false));
   rtcp_sender_->SendRtcpXrReceiverReferenceTime(false);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
-  EXPECT_EQ(0, parser()->xr_header()->num_packets());
-  EXPECT_EQ(0, parser()->rrtr()->num_packets());
+  EXPECT_EQ(0, parser()->xr()->num_packets());
 }
 
 TEST_F(RtcpSenderTest, TestRegisterRtcpPacketTypeObserver) {
@@ -704,9 +697,9 @@ TEST_F(RtcpSenderTest, SendTmmbr) {
   rtcp_sender_->SetTargetBitrate(kBitrateBps);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpTmmbr));
   EXPECT_EQ(1, parser()->tmmbr()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser()->tmmbr()->Ssrc());
-  EXPECT_EQ(1, parser()->tmmbr_item()->num_packets());
-  EXPECT_EQ(kBitrateBps / 1000, parser()->tmmbr_item()->BitrateKbps());
+  EXPECT_EQ(kSenderSsrc, parser()->tmmbr()->sender_ssrc());
+  EXPECT_EQ(1U, parser()->tmmbr()->requests().size());
+  EXPECT_EQ(kBitrateBps, parser()->tmmbr()->requests()[0].bitrate_bps());
   // TODO(asapersson): tmmbr_item()->Overhead() looks broken, always zero.
 }
 
@@ -719,11 +712,10 @@ TEST_F(RtcpSenderTest, TmmbrIncludedInCompoundPacketIfEnabled) {
   rtcp_sender_->SetTargetBitrate(kBitrateBps);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
   EXPECT_EQ(1, parser()->tmmbr()->num_packets());
-  EXPECT_EQ(1, parser()->tmmbr_item()->num_packets());
+  EXPECT_EQ(1U, parser()->tmmbr()->requests().size());
   // TMMBR should be included in each compound packet.
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
   EXPECT_EQ(2, parser()->tmmbr()->num_packets());
-  EXPECT_EQ(2, parser()->tmmbr_item()->num_packets());
 
   rtcp_sender_->SetTMMBRStatus(false);
   EXPECT_FALSE(rtcp_sender_->TMMBR());
@@ -733,21 +725,21 @@ TEST_F(RtcpSenderTest, SendTmmbn) {
   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
   rtcp_sender_->SetSendingStatus(feedback_state(), true);
   std::vector<rtcp::TmmbItem> bounding_set;
-  const uint32_t kBitrateKbps = 32768;
+  const uint32_t kBitrateBps = 32768000;
   const uint32_t kPacketOh = 40;
   const uint32_t kSourceSsrc = 12345;
-  const rtcp::TmmbItem tmmbn(kSourceSsrc, kBitrateKbps * 1000, kPacketOh);
+  const rtcp::TmmbItem tmmbn(kSourceSsrc, kBitrateBps, kPacketOh);
   bounding_set.push_back(tmmbn);
   rtcp_sender_->SetTmmbn(bounding_set);
 
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr));
   EXPECT_EQ(1, parser()->sender_report()->num_packets());
   EXPECT_EQ(1, parser()->tmmbn()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser()->tmmbn()->Ssrc());
-  EXPECT_EQ(1, parser()->tmmbn_items()->num_packets());
-  EXPECT_EQ(kBitrateKbps, parser()->tmmbn_items()->BitrateKbps(0));
-  EXPECT_EQ(kPacketOh, parser()->tmmbn_items()->Overhead(0));
-  EXPECT_EQ(kSourceSsrc, parser()->tmmbn_items()->Ssrc(0));
+  EXPECT_EQ(kSenderSsrc, parser()->tmmbn()->sender_ssrc());
+  EXPECT_EQ(1U, parser()->tmmbn()->items().size());
+  EXPECT_EQ(kBitrateBps, parser()->tmmbn()->items()[0].bitrate_bps());
+  EXPECT_EQ(kPacketOh, parser()->tmmbn()->items()[0].packet_overhead());
+  EXPECT_EQ(kSourceSsrc, parser()->tmmbn()->items()[0].ssrc());
 }
 
 // This test is written to verify actual behaviour. It does not seem
@@ -764,8 +756,8 @@ TEST_F(RtcpSenderTest, SendsTmmbnIfSetAndEmpty) {
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr));
   EXPECT_EQ(1, parser()->sender_report()->num_packets());
   EXPECT_EQ(1, parser()->tmmbn()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser()->tmmbn()->Ssrc());
-  EXPECT_EQ(0, parser()->tmmbn_items()->num_packets());
+  EXPECT_EQ(kSenderSsrc, parser()->tmmbn()->sender_ssrc());
+  EXPECT_EQ(0U, parser()->tmmbn()->items().size());
 }
 
 TEST_F(RtcpSenderTest, SendCompoundPliRemb) {
@@ -778,7 +770,7 @@ TEST_F(RtcpSenderTest, SendCompoundPliRemb) {
   packet_types.insert(kRtcpRemb);
   packet_types.insert(kRtcpPli);
   EXPECT_EQ(0, rtcp_sender_->SendCompoundRTCP(feedback_state(), packet_types));
-  EXPECT_EQ(1, parser()->remb_item()->num_packets());
+  EXPECT_EQ(1, parser()->remb()->num_packets());
   EXPECT_EQ(1, parser()->pli()->num_packets());
 }
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
index acbe56c292..dfd928c8e2 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
@@ -79,15 +79,14 @@ class SendTransport : public Transport,
   }
   bool SendRtcp(const uint8_t* data, size_t len) override {
     test::RtcpPacketParser parser;
-    parser.Parse(static_cast<const uint8_t*>(data), len);
-    last_nack_list_ = parser.nack_item()->last_nack_list();
+    parser.Parse(data, len);
+    last_nack_list_ = parser.nack()->packet_ids();
 
     if (clock_) {
       clock_->AdvanceTimeMilliseconds(delay_ms_);
     }
-    EXPECT_TRUE(receiver_ != NULL);
-    EXPECT_EQ(0, receiver_->IncomingRtcpPacket(
-        static_cast<const uint8_t*>(data), len));
+    EXPECT_TRUE(receiver_);
+    EXPECT_EQ(0, receiver_->IncomingRtcpPacket(data, len));
     return true;
   }
   ModuleRtpRtcpImpl* receiver_;
diff --git a/webrtc/test/rtcp_packet_parser.cc b/webrtc/test/rtcp_packet_parser.cc
index 65f450d2e3..2eb48c11a3 100644
--- a/webrtc/test/rtcp_packet_parser.cc
+++ b/webrtc/test/rtcp_packet_parser.cc
@@ -8,134 +8,103 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include "webrtc/base/checks.h"
+#include "webrtc/base/logging.h"
 #include "webrtc/test/rtcp_packet_parser.h"
 
-#include "testing/gtest/include/gtest/gtest.h"
-
 namespace webrtc {
 namespace test {
 
-using namespace RTCPUtility;
+RtcpPacketParser::RtcpPacketParser() = default;
+RtcpPacketParser::~RtcpPacketParser() = default;
 
-RtcpPacketParser::RtcpPacketParser() {}
-
-RtcpPacketParser::~RtcpPacketParser() {}
-
-void RtcpPacketParser::Parse(const void *data, size_t len) {
-  const uint8_t* packet = static_cast<const uint8_t*>(data);
-  RTCPUtility::RTCPParserV2 parser(packet, len, true);
-  EXPECT_TRUE(parser.IsValid());
-  for (RTCPUtility::RTCPPacketTypes type = parser.Begin();
-       type != RTCPPacketTypes::kInvalid; type = parser.Iterate()) {
-    switch (type) {
-      case RTCPPacketTypes::kSr:
-        sender_report_.Set(parser.Packet().SR);
+bool RtcpPacketParser::Parse(const void* data, size_t length) {
+  const uint8_t* const buffer = static_cast<const uint8_t*>(data);
+  const uint8_t* const buffer_end = buffer + length;
+  rtcp::CommonHeader header;
+  for (const uint8_t* next_packet = buffer; next_packet != buffer_end;
+       next_packet = header.NextPacket()) {
+    RTC_DCHECK_GT(buffer_end - next_packet, 0);
+    if (!header.Parse(next_packet, buffer_end - next_packet)) {
+      LOG(LS_WARNING)
+          << "Invalid rtcp header or unaligned rtcp packet at position "
+          << (next_packet - buffer);
+      return false;
+    }
+    switch (header.type()) {
+      case rtcp::App::kPacketType:
+        app_.Parse(header);
         break;
-      case RTCPPacketTypes::kRr:
-        receiver_report_.Set(parser.Packet().RR);
+      case rtcp::Bye::kPacketType:
+        bye_.Parse(header);
         break;
-      case RTCPPacketTypes::kReportBlockItem:
-        report_block_.Set(parser.Packet().ReportBlockItem);
-        ++report_blocks_per_ssrc_[parser.Packet().ReportBlockItem.SSRC];
+      case rtcp::ExtendedReports::kPacketType:
+        xr_.Parse(header);
         break;
-      case RTCPPacketTypes::kSdes:
-        sdes_.Set();
+      case rtcp::ExtendedJitterReport::kPacketType:
+        ij_.Parse(header);
         break;
-      case RTCPPacketTypes::kSdesChunk:
-        sdes_chunk_.Set(parser.Packet().CName);
+      case rtcp::Psfb::kPacketType:
+        switch (header.fmt()) {
+          case rtcp::Fir::kFeedbackMessageType:
+            fir_.Parse(header);
+            break;
+          case rtcp::Pli::kFeedbackMessageType:
+            pli_.Parse(header);
+            break;
+          case rtcp::Remb::kFeedbackMessageType:
+            remb_.Parse(header);
+            break;
+          case rtcp::Rpsi::kFeedbackMessageType:
+            rpsi_.Parse(header);
+            break;
+          case rtcp::Sli::kFeedbackMessageType:
+            sli_.Parse(header);
+            break;
+          default:
+            LOG(LS_WARNING) << "Unknown rtcp payload specific feedback type "
+                            << header.fmt();
+            break;
+        }
         break;
-      case RTCPPacketTypes::kBye:
-        bye_.Set(parser.Packet().BYE);
+      case rtcp::ReceiverReport::kPacketType:
+        receiver_report_.Parse(header);
         break;
-      case RTCPPacketTypes::kApp:
-        app_.Set(parser.Packet().APP);
+      case rtcp::Rtpfb::kPacketType:
+        switch (header.fmt()) {
+          case rtcp::Nack::kFeedbackMessageType:
+            nack_.Parse(header);
+            break;
+          case rtcp::RapidResyncRequest::kFeedbackMessageType:
+            rrr_.Parse(header);
+            break;
+          case rtcp::Tmmbn::kFeedbackMessageType:
+            tmmbn_.Parse(header);
+            break;
+          case rtcp::Tmmbr::kFeedbackMessageType:
+            tmmbr_.Parse(header);
+            break;
+          case rtcp::TransportFeedback::kFeedbackMessageType:
+            transport_feedback_.Parse(header);
+            break;
+          default:
+            LOG(LS_WARNING) << "Unknown rtcp transport feedback type "
+                            << header.fmt();
+            break;
+        }
         break;
-      case RTCPPacketTypes::kAppItem:
-        app_item_.Set(parser.Packet().APP);
+      case rtcp::Sdes::kPacketType:
+        sdes_.Parse(header);
         break;
-      case RTCPPacketTypes::kExtendedIj:
-        ij_.Set();
-        break;
-      case RTCPPacketTypes::kExtendedIjItem:
-        ij_item_.Set(parser.Packet().ExtendedJitterReportItem);
-        break;
-      case RTCPPacketTypes::kPsfbPli:
-        pli_.Set(parser.Packet().PLI);
-        break;
-      case RTCPPacketTypes::kPsfbSli:
-        sli_.Set(parser.Packet().SLI);
-        break;
-      case RTCPPacketTypes::kPsfbSliItem:
-        sli_item_.Set(parser.Packet().SLIItem);
-        break;
-      case RTCPPacketTypes::kPsfbRpsiItem:
-        rpsi_.Set(parser.Packet().RPSI);
-        break;
-      case RTCPPacketTypes::kPsfbFir:
-        fir_.Set(parser.Packet().FIR);
-        break;
-      case RTCPPacketTypes::kPsfbFirItem:
-        fir_item_.Set(parser.Packet().FIRItem);
-        break;
-      case RTCPPacketTypes::kRtpfbNack:
-        nack_.Set(parser.Packet().NACK);
-        nack_item_.Clear();
-        break;
-      case RTCPPacketTypes::kRtpfbNackItem:
-        nack_item_.Set(parser.Packet().NACKItem);
-        break;
-      case RTCPPacketTypes::kPsfbApp:
-        psfb_app_.Set(parser.Packet().PSFBAPP);
-        break;
-      case RTCPPacketTypes::kPsfbRembItem:
-        remb_item_.Set(parser.Packet().REMBItem);
-        break;
-      case RTCPPacketTypes::kRtpfbTmmbr:
-        tmmbr_.Set(parser.Packet().TMMBR);
-        break;
-      case RTCPPacketTypes::kRtpfbTmmbrItem:
-        tmmbr_item_.Set(parser.Packet().TMMBRItem);
-        break;
-      case RTCPPacketTypes::kRtpfbTmmbn:
-        tmmbn_.Set(parser.Packet().TMMBN);
-        tmmbn_items_.Clear();
-        break;
-      case RTCPPacketTypes::kRtpfbTmmbnItem:
-        tmmbn_items_.Set(parser.Packet().TMMBNItem);
-        break;
-      case RTCPPacketTypes::kXrHeader:
-        xr_header_.Set(parser.Packet().XR);
-        dlrr_items_.Clear();
-        break;
-      case RTCPPacketTypes::kXrReceiverReferenceTime:
-        rrtr_.Set(parser.Packet().XRReceiverReferenceTimeItem);
-        break;
-      case RTCPPacketTypes::kXrDlrrReportBlock:
-        dlrr_.Set();
-        break;
-      case RTCPPacketTypes::kXrDlrrReportBlockItem:
-        dlrr_items_.Set(parser.Packet().XRDLRRReportBlockItem);
-        break;
-      case RTCPPacketTypes::kXrVoipMetric:
-        voip_metric_.Set(parser.Packet().XRVOIPMetricItem);
+      case rtcp::SenderReport::kPacketType:
+        sender_report_.Parse(header);
         break;
       default:
+        LOG(LS_WARNING) << "Unknown rtcp packet type " << header.type();
         break;
     }
   }
-}
-
-uint64_t Rpsi::PictureId() const {
-  assert(num_packets_ > 0);
-  uint16_t num_bytes = rpsi_.NumberOfValidBits / 8;
-  assert(num_bytes > 0);
-  uint64_t picture_id = 0;
-  for (uint16_t i = 0; i < num_bytes - 1; ++i) {
-    picture_id += (rpsi_.NativeBitString[i] & 0x7f);
-    picture_id <<= 7;
-  }
-  picture_id += (rpsi_.NativeBitString[num_bytes - 1] & 0x7f);
-  return picture_id;
+  return true;
 }
 
 }  // namespace test
diff --git a/webrtc/test/rtcp_packet_parser.h b/webrtc/test/rtcp_packet_parser.h
index 562b4ed511..4fa1405e7b 100644
--- a/webrtc/test/rtcp_packet_parser.h
+++ b/webrtc/test/rtcp_packet_parser.h
@@ -12,15 +12,26 @@
 #ifndef WEBRTC_TEST_RTCP_PACKET_PARSER_H_
 #define WEBRTC_TEST_RTCP_PACKET_PARSER_H_
 
-#include <map>
-#include <string>
-#include <vector>
-
-#include "webrtc/base/buffer.h"
+#include "webrtc/base/array_view.h"
 #include "webrtc/base/checks.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/common_header.h"
-#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
-#include "webrtc/typedefs.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sli.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 
 namespace webrtc {
 namespace test {
@@ -34,693 +45,77 @@ bool ParseSinglePacket(const uint8_t* buffer, size_t size, Packet* packet) {
   return packet->Parse(header);
 }
 // Same function, but takes raw buffer as single argument instead of pair.
-template <size_t N, typename Packet>
-bool ParseSinglePacket(const uint8_t(&buffer)[N], Packet* packet) {
-  return ParseSinglePacket(buffer, N, packet);
-}
 template <typename Packet>
-bool ParseSinglePacket(const rtc::Buffer& buffer, Packet* packet) {
+bool ParseSinglePacket(rtc::ArrayView<const uint8_t> buffer, Packet* packet) {
   return ParseSinglePacket(buffer.data(), buffer.size(), packet);
 }
 
-class RtcpPacketParser;
-
-class PacketType {
- public:
-  virtual ~PacketType() {}
-
-  int num_packets() const { return num_packets_; }
-
- protected:
-  PacketType() : num_packets_(0) {}
-
-  int num_packets_;
-};
-
-class SenderReport : public PacketType {
- public:
-  SenderReport() {}
-  virtual ~SenderReport() {}
-
-  uint32_t Ssrc() const { return sr_.SenderSSRC; }
-  uint32_t NtpSec() const { return sr_.NTPMostSignificant; }
-  uint32_t NtpFrac() const { return sr_.NTPLeastSignificant; }
-  uint32_t RtpTimestamp() const { return sr_.RTPTimestamp; }
-  uint32_t PacketCount() const { return sr_.SenderPacketCount; }
-  uint32_t OctetCount() const { return sr_.SenderOctetCount; }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketSR& sr) {
-    sr_ = sr;
-    ++num_packets_;
-  }
-
-  RTCPUtility::RTCPPacketSR sr_;
-};
-
-class ReceiverReport : public PacketType {
- public:
-  ReceiverReport() {}
-  virtual ~ReceiverReport() {}
-
-  uint32_t Ssrc() const { return rr_.SenderSSRC; }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketRR& rr) {
-    rr_ = rr;
-    ++num_packets_;
-  }
-
-  RTCPUtility::RTCPPacketRR rr_;
-};
-
-class ReportBlock : public PacketType {
- public:
-  ReportBlock() {}
-  virtual ~ReportBlock() {}
-
-  uint32_t Ssrc() const { return rb_.SSRC; }
-  uint8_t FractionLost() const { return rb_.FractionLost; }
-  uint32_t CumPacketLost() const { return rb_.CumulativeNumOfPacketsLost; }
-  uint32_t ExtHighestSeqNum() const { return rb_.ExtendedHighestSequenceNumber;}
-  uint32_t Jitter() const { return rb_.Jitter; }
-  uint32_t LastSr() const { return rb_.LastSR; }
-  uint32_t DelayLastSr()const  { return rb_.DelayLastSR; }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketReportBlockItem& rb) {
-    rb_ = rb;
-    ++num_packets_;
-  }
-
-  RTCPUtility::RTCPPacketReportBlockItem rb_;
-};
-
-class Ij : public PacketType {
- public:
-  Ij() {}
-  virtual ~Ij() {}
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set() { ++num_packets_; }
-};
-
-class IjItem : public PacketType {
- public:
-  IjItem() {}
-  virtual ~IjItem() {}
-
-  uint32_t Jitter() const { return ij_item_.Jitter; }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketExtendedJitterReportItem& ij_item) {
-    ij_item_ = ij_item;
-    ++num_packets_;
-  }
-
-  RTCPUtility::RTCPPacketExtendedJitterReportItem ij_item_;
-};
-
-class Sdes : public PacketType {
- public:
-  Sdes() {}
-  virtual ~Sdes() {}
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set() { ++num_packets_; }
-};
-
-class SdesChunk : public PacketType {
- public:
-  SdesChunk() {}
-  virtual ~SdesChunk() {}
-
-  uint32_t Ssrc() const { return cname_.SenderSSRC; }
-  std::string Cname() const { return cname_.CName; }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketSDESCName& cname) {
-    cname_ = cname;
-    ++num_packets_;
-  }
-
-  RTCPUtility::RTCPPacketSDESCName cname_;
-};
-
-class Bye : public PacketType {
- public:
-  Bye() {}
-  virtual ~Bye() {}
-
-  uint32_t Ssrc() const { return bye_.SenderSSRC; }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketBYE& bye) {
-    bye_ = bye;
-    ++num_packets_;
-  }
-
-  RTCPUtility::RTCPPacketBYE bye_;
-};
-
-class Rpsi : public PacketType {
- public:
-  Rpsi() {}
-  virtual ~Rpsi() {}
-
-  uint32_t Ssrc() const { return rpsi_.SenderSSRC; }
-  uint32_t MediaSsrc() const { return rpsi_.MediaSSRC; }
-  uint8_t PayloadType() const { return rpsi_.PayloadType; }
-  uint16_t NumberOfValidBits() const { return rpsi_.NumberOfValidBits; }
-  uint64_t PictureId() const;
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketPSFBRPSI& rpsi) {
-    rpsi_ = rpsi;
-    ++num_packets_;
-  }
-
-  RTCPUtility::RTCPPacketPSFBRPSI rpsi_;
-};
-
-class App : public PacketType {
- public:
-  App() {}
-  virtual ~App() {}
-
-  uint8_t SubType() const { return app_.SubType; }
-  uint32_t Name() const { return app_.Name; }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketAPP& app) {
-    app_ = app;
-    ++num_packets_;
-  }
-
-  RTCPUtility::RTCPPacketAPP app_;
-};
-
-class AppItem : public PacketType {
- public:
-  AppItem() {}
-  virtual ~AppItem() {}
-
-  uint8_t* Data() { return app_item_.Data; }
-  uint16_t DataLength() const { return app_item_.Size; }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketAPP& app) {
-    app_item_ = app;
-    ++num_packets_;
-  }
-
-  RTCPUtility::RTCPPacketAPP app_item_;
-};
-
-class Pli : public PacketType {
- public:
-  Pli() {}
-  virtual ~Pli() {}
-
-  uint32_t Ssrc() const { return pli_.SenderSSRC; }
-  uint32_t MediaSsrc() const { return pli_.MediaSSRC; }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketPSFBPLI& pli) {
-    pli_ = pli;
-    ++num_packets_;
-  }
-
-  RTCPUtility::RTCPPacketPSFBPLI pli_;
-};
-
-class Sli : public PacketType {
- public:
-  Sli() {}
-  virtual ~Sli() {}
-
-  uint32_t Ssrc() const { return sli_.SenderSSRC; }
-  uint32_t MediaSsrc() const { return sli_.MediaSSRC; }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketPSFBSLI& sli) {
-    sli_ = sli;
-    ++num_packets_;
-  }
-
-  RTCPUtility::RTCPPacketPSFBSLI sli_;
-};
-
-class SliItem : public PacketType {
- public:
-  SliItem() {}
-  virtual ~SliItem() {}
-
-  uint16_t FirstMb() const { return sli_item_.FirstMB; }
-  uint16_t NumberOfMb() const { return sli_item_.NumberOfMB; }
-  uint8_t PictureId() const { return sli_item_.PictureId; }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketPSFBSLIItem& sli_item) {
-    sli_item_ = sli_item;
-    ++num_packets_;
-  }
-
-  RTCPUtility::RTCPPacketPSFBSLIItem sli_item_;
-};
-
-class Fir : public PacketType {
- public:
-  Fir() {}
-  virtual ~Fir() {}
-
-  uint32_t Ssrc() const { return fir_.SenderSSRC; }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketPSFBFIR& fir) {
-    fir_ = fir;
-    ++num_packets_;
-  }
-
-  RTCPUtility::RTCPPacketPSFBFIR fir_;
-};
-
-class FirItem : public PacketType {
- public:
-  FirItem() {}
-  virtual ~FirItem() {}
-
-  uint32_t Ssrc() const { return fir_item_.SSRC; }
-  uint8_t SeqNum() const { return fir_item_.CommandSequenceNumber; }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketPSFBFIRItem& fir_item) {
-    fir_item_ = fir_item;
-    ++num_packets_;
-  }
-
-  RTCPUtility::RTCPPacketPSFBFIRItem fir_item_;
-};
-
-class Nack : public PacketType {
- public:
-  Nack() {}
-  virtual ~Nack() {}
-
-  uint32_t Ssrc() const { return nack_.SenderSSRC; }
-  uint32_t MediaSsrc() const { return nack_.MediaSSRC; }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketRTPFBNACK& nack) {
-    nack_ = nack;
-    ++num_packets_;
-  }
-
-  RTCPUtility::RTCPPacketRTPFBNACK nack_;
-};
-
-class NackItem : public PacketType {
- public:
-  NackItem() {}
-  virtual ~NackItem() {}
-
-  std::vector<uint16_t> last_nack_list() const {
-    return last_nack_list_;
-  }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketRTPFBNACKItem& nack_item) {
-    last_nack_list_.push_back(nack_item.PacketID);
-    for (int i = 0; i < 16; ++i) {
-      if (nack_item.BitMask & (1 << i)) {
-        last_nack_list_.push_back(nack_item.PacketID + i + 1);
-      }
-    }
-    ++num_packets_;
-  }
-  void Clear() { last_nack_list_.clear(); }
-
-  std::vector<uint16_t> last_nack_list_;
-};
-
-class PsfbApp : public PacketType {
- public:
-  PsfbApp() {}
-  virtual ~PsfbApp() {}
-
-  uint32_t Ssrc() const { return psfb_app_.SenderSSRC; }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketPSFBAPP& psfb_app) {
-    psfb_app_ = psfb_app;
-    ++num_packets_;
-  }
-
-  RTCPUtility::RTCPPacketPSFBAPP psfb_app_;
-};
-
-class RembItem : public PacketType {
- public:
-  RembItem() : last_bitrate_bps_(0) {}
-  virtual ~RembItem() {}
-
-  int last_bitrate_bps() const { return last_bitrate_bps_; }
-  std::vector<uint32_t> last_ssrc_list() {
-    return last_ssrc_list_;
-  }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketPSFBREMBItem& remb_item) {
-    last_bitrate_bps_ = remb_item.BitRate;
-    last_ssrc_list_.clear();
-    last_ssrc_list_.insert(
-        last_ssrc_list_.end(),
-        remb_item.SSRCs,
-        remb_item.SSRCs + remb_item.NumberOfSSRCs);
-    ++num_packets_;
-  }
-
-  uint32_t last_bitrate_bps_;
-  std::vector<uint32_t> last_ssrc_list_;
-};
-
-class Tmmbr : public PacketType {
- public:
-  Tmmbr() {}
-  virtual ~Tmmbr() {}
-
-  uint32_t Ssrc() const { return tmmbr_.SenderSSRC; }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketRTPFBTMMBR& tmmbr) {
-    tmmbr_ = tmmbr;
-    ++num_packets_;
-  }
-
-  RTCPUtility::RTCPPacketRTPFBTMMBR tmmbr_;
-};
-
-class TmmbrItem : public PacketType {
- public:
-  TmmbrItem() {}
-  virtual ~TmmbrItem() {}
-
-  uint32_t Ssrc() const { return tmmbr_item_.SSRC; }
-  uint32_t BitrateKbps() const { return tmmbr_item_.MaxTotalMediaBitRate; }
-  uint32_t Overhead() const { return tmmbr_item_.MeasuredOverhead; }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketRTPFBTMMBRItem& tmmbr_item) {
-    tmmbr_item_ = tmmbr_item;
-    ++num_packets_;
-  }
-
-  RTCPUtility::RTCPPacketRTPFBTMMBRItem tmmbr_item_;
-};
-
-
-class Tmmbn : public PacketType {
- public:
-  Tmmbn() {}
-  virtual ~Tmmbn() {}
-
-  uint32_t Ssrc() const { return tmmbn_.SenderSSRC; }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketRTPFBTMMBN& tmmbn) {
-    tmmbn_ = tmmbn;
-    ++num_packets_;
-  }
-
-  RTCPUtility::RTCPPacketRTPFBTMMBN tmmbn_;
-};
-
-class TmmbnItems : public PacketType {
- public:
-  TmmbnItems() {}
-  virtual ~TmmbnItems() {}
-
-  uint32_t Ssrc(uint8_t num) const {
-    assert(num < tmmbns_.size());
-    return tmmbns_[num].SSRC;
-  }
-  uint32_t BitrateKbps(uint8_t num) const {
-    assert(num < tmmbns_.size());
-    return tmmbns_[num].MaxTotalMediaBitRate;
-  }
-  uint32_t Overhead(uint8_t num) const {
-    assert(num < tmmbns_.size());
-    return tmmbns_[num].MeasuredOverhead;
-  }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketRTPFBTMMBNItem& tmmbn_item) {
-    tmmbns_.push_back(tmmbn_item);
-    ++num_packets_;
-  }
-  void Clear() { tmmbns_.clear(); }
-
-  std::vector<RTCPUtility::RTCPPacketRTPFBTMMBNItem> tmmbns_;
-};
-
-class XrHeader : public PacketType {
- public:
-  XrHeader() {}
-  virtual ~XrHeader() {}
-
-  uint32_t Ssrc() const { return xr_header_.OriginatorSSRC; }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketXR& xr_header) {
-    xr_header_ = xr_header;
-    ++num_packets_;
-  }
-
-  RTCPUtility::RTCPPacketXR xr_header_;
-};
-
-class Rrtr : public PacketType {
- public:
-  Rrtr() {}
-  virtual ~Rrtr() {}
-
-  uint32_t NtpSec() const { return rrtr_.NTPMostSignificant; }
-  uint32_t NtpFrac() const { return rrtr_.NTPLeastSignificant; }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketXRReceiverReferenceTimeItem& rrtr) {
-    rrtr_ = rrtr;
-    ++num_packets_;
-  }
-
-  RTCPUtility::RTCPPacketXRReceiverReferenceTimeItem rrtr_;
-};
-
-class Dlrr : public PacketType {
- public:
-  Dlrr() {}
-  virtual ~Dlrr() {}
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set() { ++num_packets_; }
-};
-
-class DlrrItems : public PacketType {
- public:
-  DlrrItems() {}
-  virtual ~DlrrItems() {}
-
-  uint32_t Ssrc(uint8_t num) const {
-    assert(num < dlrrs_.size());
-    return dlrrs_[num].SSRC;
-  }
-  uint32_t LastRr(uint8_t num) const {
-    assert(num < dlrrs_.size());
-    return dlrrs_[num].LastRR;
-  }
-  uint32_t DelayLastRr(uint8_t num) const {
-    assert(num < dlrrs_.size());
-    return dlrrs_[num].DelayLastRR;
-  }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketXRDLRRReportBlockItem& dlrr) {
-    dlrrs_.push_back(dlrr);
-    ++num_packets_;
-  }
-  void Clear() { dlrrs_.clear(); }
-
-  std::vector<RTCPUtility::RTCPPacketXRDLRRReportBlockItem> dlrrs_;
-};
-
-class VoipMetric : public PacketType {
- public:
-  VoipMetric() {}
-  virtual ~VoipMetric() {}
-
-  uint32_t Ssrc() const { return voip_metric_.SSRC; }
-  uint8_t LossRate() { return voip_metric_.lossRate; }
-  uint8_t DiscardRate() { return voip_metric_.discardRate; }
-  uint8_t BurstDensity() { return voip_metric_.burstDensity; }
-  uint8_t GapDensity() { return voip_metric_.gapDensity; }
-  uint16_t BurstDuration() { return voip_metric_.burstDuration; }
-  uint16_t GapDuration() { return voip_metric_.gapDuration; }
-  uint16_t RoundTripDelay() { return voip_metric_.roundTripDelay; }
-  uint16_t EndSystemDelay() { return voip_metric_.endSystemDelay; }
-  uint8_t SignalLevel() { return voip_metric_.signalLevel; }
-  uint8_t NoiseLevel() { return voip_metric_.noiseLevel; }
-  uint8_t Rerl() { return voip_metric_.RERL; }
-  uint8_t Gmin() { return voip_metric_.Gmin; }
-  uint8_t Rfactor() { return voip_metric_.Rfactor; }
-  uint8_t ExtRfactor() { return voip_metric_.extRfactor; }
-  uint8_t MosLq() { return voip_metric_.MOSLQ; }
-  uint8_t MosCq() { return voip_metric_.MOSCQ; }
-  uint8_t RxConfig() { return voip_metric_.RXconfig; }
-  uint16_t JbNominal() { return voip_metric_.JBnominal; }
-  uint16_t JbMax() { return voip_metric_.JBmax; }
-  uint16_t JbAbsMax() { return voip_metric_.JBabsMax; }
-
- private:
-  friend class RtcpPacketParser;
-
-  void Set(const RTCPUtility::RTCPPacketXRVOIPMetricItem& voip_metric) {
-    voip_metric_ = voip_metric;
-    ++num_packets_;
-  }
-
-  RTCPUtility::RTCPPacketXRVOIPMetricItem voip_metric_;
-};
-
 class RtcpPacketParser {
  public:
+  // Keeps last parsed packet, count number of parsed packets of given type.
+  template <typename TypedRtcpPacket>
+  class PacketCounter : public TypedRtcpPacket {
+   public:
+    int num_packets() const { return num_packets_; }
+    void Parse(const rtcp::CommonHeader& header) {
+      if (TypedRtcpPacket::Parse(header))
+        ++num_packets_;
+    }
+
+   private:
+    int num_packets_ = 0;
+  };
+
   RtcpPacketParser();
   ~RtcpPacketParser();
 
-  void Parse(const void *packet, size_t packet_len);
+  bool Parse(const void* packet, size_t packet_len);
 
-  SenderReport* sender_report() { return &sender_report_; }
-  ReceiverReport* receiver_report() { return &receiver_report_; }
-  ReportBlock* report_block() { return &report_block_; }
-  Sdes* sdes() { return &sdes_; }
-  SdesChunk* sdes_chunk() { return &sdes_chunk_; }
-  Bye* bye() { return &bye_; }
-  App* app() { return &app_; }
-  AppItem* app_item() { return &app_item_; }
-  Ij* ij() { return &ij_; }
-  IjItem* ij_item() { return &ij_item_; }
-  Pli* pli() { return &pli_; }
-  Sli* sli() { return &sli_; }
-  SliItem* sli_item() { return &sli_item_; }
-  Rpsi* rpsi() { return &rpsi_; }
-  Fir* fir() { return &fir_; }
-  FirItem* fir_item() { return &fir_item_; }
-  Nack* nack() { return &nack_; }
-  NackItem* nack_item() { return &nack_item_; }
-  PsfbApp* psfb_app() { return &psfb_app_; }
-  RembItem* remb_item() { return &remb_item_; }
-  Tmmbr* tmmbr() { return &tmmbr_; }
-  TmmbrItem* tmmbr_item() { return &tmmbr_item_; }
-  Tmmbn* tmmbn() { return &tmmbn_; }
-  TmmbnItems* tmmbn_items() { return &tmmbn_items_; }
-  XrHeader* xr_header() { return &xr_header_; }
-  Rrtr* rrtr() { return &rrtr_; }
-  Dlrr* dlrr() { return &dlrr_; }
-  DlrrItems* dlrr_items() { return &dlrr_items_; }
-  VoipMetric* voip_metric() { return &voip_metric_; }
-
-  int report_blocks_per_ssrc(uint32_t ssrc) {
-    return report_blocks_per_ssrc_[ssrc];
+  PacketCounter<rtcp::App>* app() { return &app_; }
+  PacketCounter<rtcp::Bye>* bye() { return &bye_; }
+  PacketCounter<rtcp::ExtendedJitterReport>* ij() { return &ij_; }
+  PacketCounter<rtcp::ExtendedReports>* xr() { return &xr_; }
+  PacketCounter<rtcp::Fir>* fir() { return &fir_; }
+  PacketCounter<rtcp::Nack>* nack() { return &nack_; }
+  PacketCounter<rtcp::Pli>* pli() { return &pli_; }
+  PacketCounter<rtcp::RapidResyncRequest>* rrr() { return &rrr_; }
+  PacketCounter<rtcp::ReceiverReport>* receiver_report() {
+    return &receiver_report_;
+  }
+  PacketCounter<rtcp::Remb>* remb() { return &remb_; }
+  PacketCounter<rtcp::Rpsi>* rpsi() { return &rpsi_; }
+  PacketCounter<rtcp::Sdes>* sdes() { return &sdes_; }
+  PacketCounter<rtcp::SenderReport>* sender_report() { return &sender_report_; }
+  PacketCounter<rtcp::Sli>* sli() { return &sli_; }
+  PacketCounter<rtcp::Tmmbn>* tmmbn() { return &tmmbn_; }
+  PacketCounter<rtcp::Tmmbr>* tmmbr() { return &tmmbr_; }
+  PacketCounter<rtcp::TransportFeedback>* transport_feedback() {
+    return &transport_feedback_;
+  }
+  const RTCPVoIPMetric* voip_metric() {
+    return &xr_.voip_metrics()[0].voip_metric();
   }
 
  private:
-  SenderReport sender_report_;
-  ReceiverReport receiver_report_;
-  ReportBlock report_block_;
-  Sdes sdes_;
-  SdesChunk sdes_chunk_;
-  Bye bye_;
-  App app_;
-  AppItem app_item_;
-  Ij ij_;
-  IjItem ij_item_;
-  Pli pli_;
-  Sli sli_;
-  SliItem sli_item_;
-  Rpsi rpsi_;
-  Fir fir_;
-  FirItem fir_item_;
-  Nack nack_;
-  NackItem nack_item_;
-  PsfbApp psfb_app_;
-  RembItem remb_item_;
-  Tmmbr tmmbr_;
-  TmmbrItem tmmbr_item_;
-  Tmmbn tmmbn_;
-  TmmbnItems tmmbn_items_;
-  XrHeader xr_header_;
-  Rrtr rrtr_;
-  Dlrr dlrr_;
-  DlrrItems dlrr_items_;
-  VoipMetric voip_metric_;
-
-  std::map<uint32_t, int> report_blocks_per_ssrc_;
+  PacketCounter<rtcp::App> app_;
+  PacketCounter<rtcp::Bye> bye_;
+  PacketCounter<rtcp::ExtendedJitterReport> ij_;
+  PacketCounter<rtcp::ExtendedReports> xr_;
+  PacketCounter<rtcp::Fir> fir_;
+  PacketCounter<rtcp::Nack> nack_;
+  PacketCounter<rtcp::Pli> pli_;
+  PacketCounter<rtcp::RapidResyncRequest> rrr_;
+  PacketCounter<rtcp::ReceiverReport> receiver_report_;
+  PacketCounter<rtcp::Remb> remb_;
+  PacketCounter<rtcp::Rpsi> rpsi_;
+  PacketCounter<rtcp::Sdes> sdes_;
+  PacketCounter<rtcp::SenderReport> sender_report_;
+  PacketCounter<rtcp::Sli> sli_;
+  PacketCounter<rtcp::Tmmbn> tmmbn_;
+  PacketCounter<rtcp::Tmmbr> tmmbr_;
+  PacketCounter<rtcp::TransportFeedback> transport_feedback_;
 };
+
 }  // namespace test
 }  // namespace webrtc
 #endif  // WEBRTC_TEST_RTCP_PACKET_PARSER_H_
diff --git a/webrtc/video/end_to_end_tests.cc b/webrtc/video/end_to_end_tests.cc
index 26ba26a045..281e225bd8 100644
--- a/webrtc/video/end_to_end_tests.cc
+++ b/webrtc/video/end_to_end_tests.cc
@@ -746,7 +746,7 @@ TEST_F(EndToEndTest, ReceivedFecPacketsNotNacked) {
       if (state_ == kVerifyFecPacketNotInNackList) {
         test::RtcpPacketParser rtcp_parser;
         rtcp_parser.Parse(packet, length);
-        std::vector<uint16_t> nacks = rtcp_parser.nack_item()->last_nack_list();
+        const std::vector<uint16_t>& nacks = rtcp_parser.nack()->packet_ids();
         EXPECT_TRUE(std::find(nacks.begin(), nacks.end(),
                               fec_sequence_number_) == nacks.end())
             << "Got nack for FEC packet";
@@ -2034,7 +2034,7 @@ TEST_F(EndToEndTest, VerifyNackStats) {
       rtc::CritScope lock(&crit_);
       test::RtcpPacketParser rtcp_parser;
       rtcp_parser.Parse(packet, length);
-      std::vector<uint16_t> nacks = rtcp_parser.nack_item()->last_nack_list();
+      const std::vector<uint16_t>& nacks = rtcp_parser.nack()->packet_ids();
       if (!nacks.empty() && std::find(
           nacks.begin(), nacks.end(), dropped_rtp_packet_) != nacks.end()) {
         dropped_rtp_packet_requested_ = true;
@@ -3155,8 +3155,8 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx,
       test::RtcpPacketParser rtcp_parser;
       rtcp_parser.Parse(packet, length);
       if (rtcp_parser.sender_report()->num_packets() > 0) {
-        uint32_t ssrc = rtcp_parser.sender_report()->Ssrc();
-        uint32_t rtcp_timestamp = rtcp_parser.sender_report()->RtpTimestamp();
+        uint32_t ssrc = rtcp_parser.sender_report()->sender_ssrc();
+        uint32_t rtcp_timestamp = rtcp_parser.sender_report()->rtp_timestamp();
 
         rtc::CritScope lock(&crit_);
         ValidateTimestampGap(ssrc, rtcp_timestamp, false);