Test RtcpParser rewritten to use rtcp packet classes

webrtc/test/rtcp_packet_parser.h

 /*
  *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  *
  */
 
 #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 {
 // Parse RTCP packet of given type. Assumes RTCP header is valid and that there
 // is excatly one packet of correct type in the buffer.
 template <typename Packet>
 bool ParseSinglePacket(const uint8_t* buffer, size_t size, Packet* packet) {
   rtcp::CommonHeader header;
   RTC_CHECK(header.Parse(buffer, size));
   RTC_CHECK_EQ(static_cast<ptrdiff_t>(size), header.NextPacket() - buffer);
   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 RtcpPacketParser {
+ public:
+  // Keeps last parsed packet, count number of parsed packets of given type.
+  template <typename RtcpPacket>
+  class PacketCounter : public RtcpPacket {
+   public:
+    int num_packets() const { return num_packets_; }
+    void Parse(const rtcp::CommonHeader& header) {
+      if (RtcpPacket::Parse(header))
+        ++num_packets_;
+    }
 
-class PacketType {
- public:
-  virtual ~PacketType() {}
+   private:
+    int num_packets_ = 0;
+  };
 
-  int num_packets() const { return num_packets_; }
+  RtcpPacketParser();
+  ~RtcpPacketParser();
 
- protected:
-  PacketType() : num_packets_(0) {}
+  bool Parse(const void* packet, size_t packet_len);
 
-  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_;
+  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_;
   }
-
-  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_;
+  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_;
   }
-
-  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_;
+  const RTCPVoIPMetric* voip_metric() {
+    return &xr_.voip_metrics()[0].voip_metric();
   }
 
  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_;
+  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_;
 };
 
-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:
-  RtcpPacketParser();
-  ~RtcpPacketParser();
-
-  void 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];
-  }
-
- 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_;
-};
 }  // namespace test
 }  // namespace webrtc
 #endif  // WEBRTC_TEST_RTCP_PACKET_PARSER_H_