Move class RTCPHelp::RTCPPacketInformation into RTCPReceiver

webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/modules/rtp_rtcp/source/rtcp_receiver.h"
 
 #include <assert.h>
 #include <string.h>
 
 #include <limits>
+#include <memory>
+#include <utility>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/trace_event.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_packet/compound_packet.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"
@@ skipping 11 matching lines @@
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
 #include "webrtc/modules/rtp_rtcp/source/time_util.h"
 #include "webrtc/modules/rtp_rtcp/source/tmmbr_help.h"
 #include "webrtc/system_wrappers/include/ntp_time.h"
 
 namespace webrtc {
 namespace {
 
 using rtcp::CommonHeader;
 using rtcp::ReportBlock;
-using RTCPHelp::RTCPPacketInformation;
 using RTCPHelp::RTCPReceiveInformation;
 using RTCPHelp::RTCPReportBlockInformation;
 using RTCPUtility::RTCPCnameInformation;
 using RTCPUtility::RTCPPacketReportBlockItem;
 using RTCPUtility::RTCPPacketTypes;
 
 // The number of RTCP time intervals needed to trigger a timeout.
 const int kRrTimeoutIntervals = 3;
 
 const int64_t kMaxWarningLogIntervalMs = 10000;
 
 }  // namespace
 
+class RTCPReceiver::PacketInformation {
+ public:
+  PacketInformation();
+  ~PacketInformation();
+
+  void AddReportInfo(const RTCPReportBlockInformation& report_block_info);
+
+  uint32_t rtcpPacketTypeFlags;  // RTCPPacketTypeFlags bit field

[philipel, 2016/09/23 11:33:01]

Change all camelCase to use underscore as separator instead in this class.

[danilchap, 2016/09/23 12:35:55]

Planned to do PacketInformation cleanup in follow-up CL, but if you do not mind
to review it here, here it is.
If you prefer cleanup moved to follow-up (there is more cleanup than just
renaming), I do not mind to revert this patchset.

+  uint32_t remoteSSRC;
+
+  std::vector<uint16_t> nackSequenceNumbers;
+
+  ReportBlockList report_blocks;
+  int64_t rtt;
+
+  uint8_t sliPictureId;
+  uint64_t rpsiPictureId;
+  uint32_t receiverEstimatedMaxBitrate;
+
+  uint32_t ntp_secs;
+  uint32_t ntp_frac;
+  uint32_t rtp_timestamp;
+
+  uint32_t xr_originator_ssrc;
+  bool xr_dlrr_item;
+
+  std::unique_ptr<rtcp::TransportFeedback> transport_feedback_;
+
+ private:
+  RTC_DISALLOW_COPY_AND_ASSIGN(PacketInformation);
+};
+
+RTCPReceiver::PacketInformation::PacketInformation()
+    : rtcpPacketTypeFlags(0),
+      remoteSSRC(0),
+      nackSequenceNumbers(),
+      rtt(0),
+      sliPictureId(0),
+      rpsiPictureId(0),
+      receiverEstimatedMaxBitrate(0),
+      ntp_secs(0),
+      ntp_frac(0),
+      rtp_timestamp(0),
+      xr_originator_ssrc(0),
+      xr_dlrr_item(false) {}
+
+RTCPReceiver::PacketInformation::~PacketInformation() {}

[philipel, 2016/09/23 11:33:01]

Remove dtor

[danilchap, 2016/09/23 12:35:55]

Done.

+
+void RTCPReceiver::PacketInformation::AddReportInfo(
+    const RTCPReportBlockInformation& report_block_info) {
+  this->rtt = report_block_info.RTT;
+  report_blocks.push_back(report_block_info.remoteReceiveBlock);
+}
+
 RTCPReceiver::RTCPReceiver(
     Clock* clock,
     bool receiver_only,
     RtcpPacketTypeCounterObserver* packet_type_counter_observer,
     RtcpBandwidthObserver* rtcp_bandwidth_observer,
     RtcpIntraFrameObserver* rtcp_intra_frame_observer,
     TransportFeedbackObserver* transport_feedback_observer,
     ModuleRtpRtcp* owner)
     : _clock(clock),
       receiver_only_(receiver_only),
@@ skipping 43 matching lines @@
     _receivedCnameMap.erase(first);
   }
 }
 
 bool RTCPReceiver::IncomingPacket(const uint8_t* packet, size_t packet_size) {
   if (packet_size == 0) {
     LOG(LS_WARNING) << "Incoming empty RTCP packet";
     return false;
   }
 
-  RTCPHelp::RTCPPacketInformation packet_information;
+  PacketInformation packet_information;
   if (!ParseCompoundPacket(packet, packet + packet_size, &packet_information))
     return false;
   TriggerCallbacksFromRTCPPacket(packet_information);
   return true;
 }
 
 int64_t RTCPReceiver::LastReceivedReceiverReport() const {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   int64_t last_received_rr = -1;
   for (ReceivedInfoMap::const_iterator it = _receivedInfoMap.begin();
@@ skipping 153 matching lines @@
   for (; it != _receivedReportBlockMap.end(); ++it) {
     const ReportBlockInfoMap* info_map = &(it->second);
     ReportBlockInfoMap::const_iterator it_info = info_map->begin();
     for (; it_info != info_map->end(); ++it_info) {
       receiveBlocks->push_back(it_info->second->remoteReceiveBlock);
     }
   }
   return 0;
 }
 
-bool RTCPReceiver::ParseCompoundPacket(
-    const uint8_t* packet_begin,
-    const uint8_t* packet_end,
-    RTCPPacketInformation* packet_information) {
+bool RTCPReceiver::ParseCompoundPacket(const uint8_t* packet_begin,
+                                       const uint8_t* packet_end,
+                                       PacketInformation* packet_information) {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
 
   CommonHeader rtcp_block;
   for (const uint8_t* next_block = packet_begin; next_block != packet_end;
        next_block = rtcp_block.NextPacket()) {
     ptrdiff_t remaining_blocks_size = packet_end - next_block;
     RTC_DCHECK_GT(remaining_blocks_size, 0);
     if (!rtcp_block.Parse(next_block, remaining_blocks_size)) {
       if (next_block == packet_begin) {
         // Failed to parse 1st header, nothing was extracted from this packet.
         LOG(LS_WARNING) << "Incoming invalid RTCP packet";
         return false;
       }
       ++num_skipped_packets_;
       break;
     }
 
     if (packet_type_counter_.first_packet_time_ms == -1)
       packet_type_counter_.first_packet_time_ms = _clock->TimeInMilliseconds();
 
     switch (rtcp_block.type()) {
       case rtcp::SenderReport::kPacketType:
-        HandleSenderReport(rtcp_block, *packet_information);
+        HandleSenderReport(rtcp_block, packet_information);
         break;
       case rtcp::ReceiverReport::kPacketType:
-        HandleReceiverReport(rtcp_block, *packet_information);
+        HandleReceiverReport(rtcp_block, packet_information);
         break;
       case rtcp::Sdes::kPacketType:
-        HandleSDES(rtcp_block, *packet_information);
+        HandleSDES(rtcp_block, packet_information);
         break;
       case rtcp::ExtendedReports::kPacketType:
-        HandleXr(rtcp_block, *packet_information);
+        HandleXr(rtcp_block, packet_information);
         break;
       case rtcp::Bye::kPacketType:
         HandleBYE(rtcp_block);
         break;
       case rtcp::Rtpfb::kPacketType:
         switch (rtcp_block.fmt()) {
           case rtcp::Nack::kFeedbackMessageType:
-            HandleNACK(rtcp_block, *packet_information);
+            HandleNACK(rtcp_block, packet_information);
             break;
           case rtcp::Tmmbr::kFeedbackMessageType:
-            HandleTMMBR(rtcp_block, *packet_information);
+            HandleTMMBR(rtcp_block, packet_information);
             break;
           case rtcp::Tmmbn::kFeedbackMessageType:
-            HandleTMMBN(rtcp_block, *packet_information);
+            HandleTMMBN(rtcp_block, packet_information);
             break;
           case rtcp::RapidResyncRequest::kFeedbackMessageType:
-            HandleSR_REQ(rtcp_block, *packet_information);
+            HandleSR_REQ(rtcp_block, packet_information);
             break;
           case rtcp::TransportFeedback::kFeedbackMessageType:
             HandleTransportFeedback(rtcp_block, packet_information);
             break;
           default:
             ++num_skipped_packets_;
             break;
         }
         break;
       case rtcp::Psfb::kPacketType:
         switch (rtcp_block.fmt()) {
           case rtcp::Pli::kFeedbackMessageType:
-            HandlePLI(rtcp_block, *packet_information);
+            HandlePLI(rtcp_block, packet_information);
             break;
           case rtcp::Sli::kFeedbackMessageType:
-            HandleSLI(rtcp_block, *packet_information);
+            HandleSLI(rtcp_block, packet_information);
             break;
           case rtcp::Rpsi::kFeedbackMessageType:
-            HandleRPSI(rtcp_block, *packet_information);
+            HandleRPSI(rtcp_block, packet_information);
             break;
           case rtcp::Fir::kFeedbackMessageType:
-            HandleFIR(rtcp_block, *packet_information);
+            HandleFIR(rtcp_block, packet_information);
             break;
           case rtcp::Remb::kFeedbackMessageType:
-            HandlePsfbApp(rtcp_block, *packet_information);
+            HandlePsfbApp(rtcp_block, packet_information);
             break;
           default:
             ++num_skipped_packets_;
             break;
         }
         break;
       default:
         ++num_skipped_packets_;
         break;
     }
@@ skipping 10 matching lines @@
     last_skipped_packets_warning_ = now;
     LOG(LS_WARNING) << num_skipped_packets_
                     << " RTCP blocks were skipped due to being malformed or of "
                        "unrecognized/unsupported type, during the past "
                     << (kMaxWarningLogIntervalMs / 1000) << " second period.";
   }
 
   return true;
 }
 
-void RTCPReceiver::HandleSenderReport(
-    const CommonHeader& rtcp_block,
-    RTCPPacketInformation& rtcpPacketInformation) {
+void RTCPReceiver::HandleSenderReport(const CommonHeader& rtcp_block,
+                                      PacketInformation* packet_information) {
   rtcp::SenderReport sender_report;
   if (!sender_report.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
   const uint32_t remoteSSRC = sender_report.sender_ssrc();
 
-  rtcpPacketInformation.remoteSSRC = remoteSSRC;
+  packet_information->remoteSSRC = remoteSSRC;
 
   RTCPReceiveInformation* ptrReceiveInfo = CreateReceiveInformation(remoteSSRC);
   if (!ptrReceiveInfo)
     return;
 
   TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "SR",
                        "remote_ssrc", remoteSSRC, "ssrc", main_ssrc_);
 
   // Have I received RTP packets from this party?
   if (_remoteSSRC == remoteSSRC) {
     // Only signal that we have received a SR when we accept one.
-    rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSr;
+    packet_information->rtcpPacketTypeFlags |= kRtcpSr;
 
-    rtcpPacketInformation.ntp_secs = sender_report.ntp().seconds();
-    rtcpPacketInformation.ntp_frac = sender_report.ntp().fractions();
-    rtcpPacketInformation.rtp_timestamp = sender_report.rtp_timestamp();
+    packet_information->ntp_secs = sender_report.ntp().seconds();
+    packet_information->ntp_frac = sender_report.ntp().fractions();
+    packet_information->rtp_timestamp = sender_report.rtp_timestamp();
 
     // Save the NTP time of this report.
     _remoteSenderInfo.NTPseconds = sender_report.ntp().seconds();
     _remoteSenderInfo.NTPfraction = sender_report.ntp().fractions();
     _remoteSenderInfo.RTPtimeStamp = sender_report.rtp_timestamp();
     _remoteSenderInfo.sendPacketCount = sender_report.sender_packet_count();
     _remoteSenderInfo.sendOctetCount = sender_report.sender_octet_count();
 
     _clock->CurrentNtp(_lastReceivedSRNTPsecs, _lastReceivedSRNTPfrac);
   } else {
     // We will only store the send report from one source, but
     // we will store all the receive blocks.
-    rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRr;
+    packet_information->rtcpPacketTypeFlags |= kRtcpRr;
   }
   // Update that this remote is alive.
   ptrReceiveInfo->last_time_received_ms = _clock->TimeInMilliseconds();
 
   for (const rtcp::ReportBlock report_block : sender_report.report_blocks())
-    HandleReportBlock(report_block, rtcpPacketInformation, remoteSSRC);
+    HandleReportBlock(report_block, packet_information, remoteSSRC);
 }
 
-void RTCPReceiver::HandleReceiverReport(
-    const CommonHeader& rtcp_block,
-    RTCPPacketInformation& rtcpPacketInformation) {
+void RTCPReceiver::HandleReceiverReport(const CommonHeader& rtcp_block,
+                                        PacketInformation* packet_information) {
   rtcp::ReceiverReport receiver_report;
   if (!receiver_report.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
   const uint32_t remoteSSRC = receiver_report.sender_ssrc();
 
-  rtcpPacketInformation.remoteSSRC = remoteSSRC;
+  packet_information->remoteSSRC = remoteSSRC;
 
   RTCPReceiveInformation* ptrReceiveInfo = CreateReceiveInformation(remoteSSRC);
   if (!ptrReceiveInfo)
     return;
 
   TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR",
                        "remote_ssrc", remoteSSRC, "ssrc", main_ssrc_);
 
-  rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRr;
+  packet_information->rtcpPacketTypeFlags |= kRtcpRr;
 
   // Update that this remote is alive.
   ptrReceiveInfo->last_time_received_ms = _clock->TimeInMilliseconds();
 
   for (const ReportBlock& report_block : receiver_report.report_blocks())
-    HandleReportBlock(report_block, rtcpPacketInformation, remoteSSRC);
+    HandleReportBlock(report_block, packet_information, remoteSSRC);
 }
 
-void RTCPReceiver::HandleReportBlock(
-    const ReportBlock& report_block,
-    RTCPPacketInformation& rtcpPacketInformation,
-    uint32_t remoteSSRC) {
+void RTCPReceiver::HandleReportBlock(const ReportBlock& report_block,
+                                     PacketInformation* packet_information,
+                                     uint32_t remoteSSRC) {
   // This will be called once per report block in the RTCP packet.
   // We filter out all report blocks that are not for us.
   // Each packet has max 31 RR blocks.
   //
   // We can calc RTT if we send a send report and get a report block back.
 
   // |rtcpPacket.ReportBlockItem.SSRC| is the SSRC identifier of the source to
   // which the information in this reception report block pertains.
 
   // Filter out all report blocks that are not for us.
@@ skipping 68 matching lines @@
     } else {
       // First RTT.
       reportBlock->avgRTT = rtt;
     }
     reportBlock->numAverageCalcs++;
   }
 
   TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR_RTT",
                     report_block.source_ssrc(), rtt);
 
-  rtcpPacketInformation.AddReportInfo(*reportBlock);
+  packet_information->AddReportInfo(*reportBlock);
 }
 
 RTCPReportBlockInformation* RTCPReceiver::CreateOrGetReportBlockInformation(
     uint32_t remote_ssrc,
     uint32_t source_ssrc) {
   RTCPReportBlockInformation* info =
       GetReportBlockInformation(remote_ssrc, source_ssrc);
   if (info == NULL) {
     info = new RTCPReportBlockInformation;
     _receivedReportBlockMap[source_ssrc][remote_ssrc] = info;
@@ skipping 155 matching lines @@
     return std::vector<rtcp::TmmbItem>();
   }
   RTCPReceiveInformation* receiveInfo = receiveInfoIt->second;
   RTC_DCHECK(receiveInfo);
 
   *tmmbr_owner = TMMBRHelp::IsOwner(receiveInfo->tmmbn, main_ssrc_);
   return receiveInfo->tmmbn;
 }
 
 void RTCPReceiver::HandleSDES(const CommonHeader& rtcp_block,
-                              RTCPPacketInformation& rtcpPacketInformation) {
+                              PacketInformation* packet_information) {
   rtcp::Sdes sdes;
   if (!sdes.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
   for (const rtcp::Sdes::Chunk& chunk : sdes.chunks()) {
     RTCPCnameInformation* cnameInfo = CreateCnameInformation(chunk.ssrc);
     RTC_DCHECK(cnameInfo);
 
     cnameInfo->name[RTCP_CNAME_SIZE - 1] = 0;
     strncpy(cnameInfo->name, chunk.cname.c_str(), RTCP_CNAME_SIZE - 1);
     {
       rtc::CritScope lock(&_criticalSectionFeedbacks);
       if (stats_callback_)
         stats_callback_->CNameChanged(chunk.cname.c_str(), chunk.ssrc);
     }
   }
-  rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSdes;
+  packet_information->rtcpPacketTypeFlags |= kRtcpSdes;
 }
 
 void RTCPReceiver::HandleNACK(const CommonHeader& rtcp_block,
-                              RTCPPacketInformation& rtcpPacketInformation) {
+                              PacketInformation* packet_information) {
   rtcp::Nack nack;
   if (!nack.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
   if (receiver_only_ || main_ssrc_ != nack.media_ssrc())  // Not to us.
     return;
 
-  rtcpPacketInformation.nackSequenceNumbers = nack.packet_ids();
+  packet_information->nackSequenceNumbers = nack.packet_ids();
   for (uint16_t packet_id : nack.packet_ids())
     nack_stats_.ReportRequest(packet_id);
 
   if (!nack.packet_ids().empty()) {
-    rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpNack;
+    packet_information->rtcpPacketTypeFlags |= kRtcpNack;
     ++packet_type_counter_.nack_packets;
     packet_type_counter_.nack_requests = nack_stats_.requests();
     packet_type_counter_.unique_nack_requests = nack_stats_.unique_requests();
   }
 }
 
 void RTCPReceiver::HandleBYE(const CommonHeader& rtcp_block) {
   rtcp::Bye bye;
   if (!bye.Parse(rtcp_block)) {
     ++num_skipped_packets_;
@@ skipping 22 matching lines @@
       _receivedCnameMap.find(bye.sender_ssrc());
 
   if (cnameInfoIt != _receivedCnameMap.end()) {
     delete cnameInfoIt->second;
     _receivedCnameMap.erase(cnameInfoIt);
   }
   xr_rr_rtt_ms_ = 0;
 }
 
 void RTCPReceiver::HandleXr(const CommonHeader& rtcp_block,
-                            RTCPPacketInformation& rtcpPacketInformation) {
+                            PacketInformation* packet_information) {
   rtcp::ExtendedReports xr;
   if (!xr.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
-  rtcpPacketInformation.xr_originator_ssrc = xr.sender_ssrc();
+  packet_information->xr_originator_ssrc = xr.sender_ssrc();
   for (const rtcp::Rrtr& rrtr : xr.rrtrs())
-    HandleXrReceiveReferenceTime(rrtr, rtcpPacketInformation);
+    HandleXrReceiveReferenceTime(rrtr, packet_information);
 
   for (const rtcp::Dlrr& dlrr : xr.dlrrs()) {
     for (const rtcp::ReceiveTimeInfo& time_info : dlrr.sub_blocks())
-      HandleXrDlrrReportBlock(time_info, rtcpPacketInformation);
+      HandleXrDlrrReportBlock(time_info, packet_information);
   }
 }
 
 void RTCPReceiver::HandleXrReceiveReferenceTime(
     const rtcp::Rrtr& rrtr,
-    RTCPPacketInformation& rtcpPacketInformation) {
-  _remoteXRReceiveTimeInfo.sourceSSRC =
-      rtcpPacketInformation.xr_originator_ssrc;
+    PacketInformation* packet_information) {
+  _remoteXRReceiveTimeInfo.sourceSSRC = packet_information->xr_originator_ssrc;
 
   _remoteXRReceiveTimeInfo.lastRR = CompactNtp(rrtr.ntp());
 
   _clock->CurrentNtp(_lastReceivedXRNTPsecs, _lastReceivedXRNTPfrac);
 
-  rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrReceiverReferenceTime;
+  packet_information->rtcpPacketTypeFlags |= kRtcpXrReceiverReferenceTime;
 }
 
 void RTCPReceiver::HandleXrDlrrReportBlock(
     const rtcp::ReceiveTimeInfo& rti,
-    RTCPPacketInformation& rtcpPacketInformation) {
+    PacketInformation* packet_information) {
   if (registered_ssrcs_.count(rti.ssrc) == 0)  // Not to us.
     return;
 
-  rtcpPacketInformation.xr_dlrr_item = true;
+  packet_information->xr_dlrr_item = true;
 
   // Caller should explicitly enable rtt calculation using extended reports.
   if (!xr_rrtr_status_)
     return;
 
   // The send_time and delay_rr fields are in units of 1/2^16 sec.
   uint32_t send_time = rti.last_rr;
   // RFC3611, section 4.5, LRR field discription states:
   // If no such block has been received, the field is set to zero.
   if (send_time == 0)
     return;
 
   uint32_t delay_rr = rti.delay_since_last_rr;
   uint32_t now = CompactNtp(NtpTime(*_clock));
 
   uint32_t rtt_ntp = now - delay_rr - send_time;
   xr_rr_rtt_ms_ = CompactNtpRttToMs(rtt_ntp);
 
-  rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrDlrrReportBlock;
+  packet_information->rtcpPacketTypeFlags |= kRtcpXrDlrrReportBlock;
 }
 
 void RTCPReceiver::HandlePLI(const CommonHeader& rtcp_block,
-                             RTCPPacketInformation& rtcpPacketInformation) {
+                             PacketInformation* packet_information) {
   rtcp::Pli pli;
   if (!pli.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
   if (main_ssrc_ == pli.media_ssrc()) {
     TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PLI");
 
     ++packet_type_counter_.pli_packets;
     // Received a signal that we need to send a new key frame.
-    rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpPli;
+    packet_information->rtcpPacketTypeFlags |= kRtcpPli;
   }
 }
 
 void RTCPReceiver::HandleTMMBR(const CommonHeader& rtcp_block,
-                               RTCPPacketInformation& rtcpPacketInformation) {
+                               PacketInformation* packet_information) {
   rtcp::Tmmbr tmmbr;
   if (!tmmbr.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
   uint32_t senderSSRC = tmmbr.sender_ssrc();
   RTCPReceiveInformation* ptrReceiveInfo = GetReceiveInformation(senderSSRC);
   if (!ptrReceiveInfo)  // This remote SSRC must be saved before.
     return;
 
   if (tmmbr.media_ssrc()) {
     // media_ssrc() SHOULD be 0 if same as SenderSSRC.
     // In relay mode this is a valid number.
     senderSSRC = tmmbr.media_ssrc();
   }
 
   for (const rtcp::TmmbItem& request : tmmbr.requests()) {
     if (main_ssrc_ == request.ssrc() && request.bitrate_bps()) {
       ptrReceiveInfo->InsertTmmbrItem(senderSSRC, request,
                                       _clock->TimeInMilliseconds());
-      rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpTmmbr;
+      packet_information->rtcpPacketTypeFlags |= kRtcpTmmbr;
     }
   }
 }
 
 void RTCPReceiver::HandleTMMBN(const CommonHeader& rtcp_block,
-                               RTCPPacketInformation& rtcpPacketInformation) {
+                               PacketInformation* packet_information) {
   rtcp::Tmmbn tmmbn;
   if (!tmmbn.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
   RTCPReceiveInformation* ptrReceiveInfo =
       GetReceiveInformation(tmmbn.sender_ssrc());
   if (!ptrReceiveInfo)  // This remote SSRC must be saved before.
     return;
 
-  rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpTmmbn;
+  packet_information->rtcpPacketTypeFlags |= kRtcpTmmbn;
 
   for (const auto& item : tmmbn.items())
     ptrReceiveInfo->tmmbn.push_back(item);
 }
 
 void RTCPReceiver::HandleSR_REQ(const CommonHeader& rtcp_block,
-                                RTCPPacketInformation& rtcpPacketInformation) {
+                                PacketInformation* packet_information) {
   rtcp::RapidResyncRequest sr_req;
   if (!sr_req.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
-  rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSrReq;
+  packet_information->rtcpPacketTypeFlags |= kRtcpSrReq;
 }
 
 void RTCPReceiver::HandleSLI(const CommonHeader& rtcp_block,
-                             RTCPPacketInformation& rtcpPacketInformation) {
+                             PacketInformation* packet_information) {
   rtcp::Sli sli;
   if (!sli.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
   for (const rtcp::Sli::Macroblocks& item : sli.macroblocks()) {
     // In theory there could be multiple slices lost.
     // Received signal that we need to refresh a slice.
-    rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSli;
-    rtcpPacketInformation.sliPictureId = item.picture_id();
+    packet_information->rtcpPacketTypeFlags |= kRtcpSli;
+    packet_information->sliPictureId = item.picture_id();
   }
 }
 
-void RTCPReceiver::HandleRPSI(
-    const CommonHeader& rtcp_block,
-    RTCPHelp::RTCPPacketInformation& rtcpPacketInformation) {
+void RTCPReceiver::HandleRPSI(const CommonHeader& rtcp_block,
+                              PacketInformation* packet_information) {
   rtcp::Rpsi rpsi;
   if (!rpsi.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
   // Received signal that we have a confirmed reference picture.
-  rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRpsi;
-  rtcpPacketInformation.rpsiPictureId = rpsi.picture_id();
+  packet_information->rtcpPacketTypeFlags |= kRtcpRpsi;
+  packet_information->rpsiPictureId = rpsi.picture_id();
 }
 
 void RTCPReceiver::HandlePsfbApp(const CommonHeader& rtcp_block,
-                                 RTCPPacketInformation& rtcpPacketInformation) {
+                                 PacketInformation* packet_information) {
   rtcp::Remb remb;
   if (remb.Parse(rtcp_block)) {
-    rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRemb;
-    rtcpPacketInformation.receiverEstimatedMaxBitrate = remb.bitrate_bps();
+    packet_information->rtcpPacketTypeFlags |= kRtcpRemb;
+    packet_information->receiverEstimatedMaxBitrate = remb.bitrate_bps();
     return;
   }
 
   ++num_skipped_packets_;
 }
 
 void RTCPReceiver::HandleFIR(const CommonHeader& rtcp_block,
-                             RTCPPacketInformation& rtcpPacketInformation) {
+                             PacketInformation* packet_information) {
   rtcp::Fir fir;
   if (!fir.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
   RTCPReceiveInformation* ptrReceiveInfo =
       GetReceiveInformation(fir.sender_ssrc());
 
   for (const rtcp::Fir::Request& fir_request : fir.requests()) {
     // Is it our sender that is requested to generate a new keyframe
     if (main_ssrc_ != fir_request.ssrc)
       continue;
 
     ++packet_type_counter_.fir_packets;
 
     // rtcpPacket.FIR.MediaSSRC SHOULD be 0 but we ignore to check it
     // we don't know who this originate from
     if (ptrReceiveInfo) {
       // check if we have reported this FIRSequenceNumber before
       if (fir_request.seq_nr != ptrReceiveInfo->last_fir_sequence_number) {
         int64_t now = _clock->TimeInMilliseconds();
         // sanity; don't go crazy with the callbacks
         if ((now - ptrReceiveInfo->last_fir_request_ms) >
             RTCP_MIN_FRAME_LENGTH_MS) {
           ptrReceiveInfo->last_fir_request_ms = now;
           ptrReceiveInfo->last_fir_sequence_number = fir_request.seq_nr;
           // received signal that we need to send a new key frame
-          rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpFir;
+          packet_information->rtcpPacketTypeFlags |= kRtcpFir;
         }
       }
     } else {
       // received signal that we need to send a new key frame
-      rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpFir;
+      packet_information->rtcpPacketTypeFlags |= kRtcpFir;
     }
   }
 }
 
 void RTCPReceiver::HandleTransportFeedback(
     const CommonHeader& rtcp_block,
-    RTCPHelp::RTCPPacketInformation* rtcp_packet_information) {
+    PacketInformation* packet_information) {
   std::unique_ptr<rtcp::TransportFeedback> transport_feedback(
       new rtcp::TransportFeedback());
   if (!transport_feedback->Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
-  rtcp_packet_information->rtcpPacketTypeFlags |= kRtcpTransportFeedback;
-  rtcp_packet_information->transport_feedback_ = std::move(transport_feedback);
+  packet_information->rtcpPacketTypeFlags |= kRtcpTransportFeedback;
+  packet_information->transport_feedback_ = std::move(transport_feedback);
 }
 
 void RTCPReceiver::UpdateTmmbr() {
   // Find bounding set.
   std::vector<rtcp::TmmbItem> bounding =
       TMMBRHelp::FindBoundingSet(TmmbrReceived());
 
   if (!bounding.empty() && _cbRtcpBandwidthObserver) {
     // We have a new bandwidth estimate on this channel.
     uint64_t bitrate_bps = TMMBRHelp::CalcMinBitrateBps(bounding);
@@ skipping 11 matching lines @@
   stats_callback_ = callback;
 }
 
 RtcpStatisticsCallback* RTCPReceiver::GetRtcpStatisticsCallback() {
   rtc::CritScope cs(&_criticalSectionFeedbacks);
   return stats_callback_;
 }
 
 // Holding no Critical section
 void RTCPReceiver::TriggerCallbacksFromRTCPPacket(
-    RTCPPacketInformation& rtcpPacketInformation) {
+    const PacketInformation& rtcpPacketInformation) {
   // Process TMMBR and REMB first to avoid multiple callbacks
   // to OnNetworkChanged.
   if (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpTmmbr) {
     // Might trigger a OnReceivedBandwidthEstimateUpdate.
     UpdateTmmbr();
   }
   uint32_t local_ssrc;
   std::set<uint32_t> registered_ssrcs;
   {
     // We don't want to hold this critsect when triggering the callbacks below.
@@ skipping 113 matching lines @@
 
   for (const auto& kv : _receivedInfoMap) {
     RTCPReceiveInformation* receive_info = kv.second;
     RTC_DCHECK(receive_info);
     receive_info->GetTmmbrSet(now_ms, &candidates);
   }
   return candidates;
 }
 
 }  // namespace webrtc