Adjust RtcpReceiver to be testable with callbacks:

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 "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
-#include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.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 {
 using RTCPHelp::RTCPPacketInformation;
 using RTCPHelp::RTCPReceiveInformation;
 using RTCPHelp::RTCPReportBlockInformation;
 using RTCPUtility::kBtVoipMetric;
 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;
 
 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,
-    ModuleRtpRtcpImpl* owner)
+    ModuleRtpRtcp* owner)
     : _clock(clock),
       receiver_only_(receiver_only),
       _lastReceived(0),
       _rtpRtcp(*owner),
       _cbRtcpBandwidthObserver(rtcp_bandwidth_observer),
       _cbRtcpIntraFrameObserver(rtcp_intra_frame_observer),
       _cbTransportFeedbackObserver(transport_feedback_observer),
       main_ssrc_(0),
       _remoteSSRC(0),
       _remoteSenderInfo(),
@@ skipping 30 matching lines @@
     _receivedInfoMap.erase(first);
   }
   while (!_receivedCnameMap.empty()) {
     std::map<uint32_t, RTCPCnameInformation*>::iterator first =
         _receivedCnameMap.begin();
     delete first->second;
     _receivedCnameMap.erase(first);
   }
 }
 
+bool RTCPReceiver::IncomingPacket(const uint8_t* packet, size_t packet_size) {
+  // Allow receive of non-compound RTCP packets.
+  RTCPUtility::RTCPParserV2 rtcp_parser(packet, packet_size, true);
+
+  if (!rtcp_parser.IsValid()) {
+    LOG(LS_WARNING) << "Incoming invalid RTCP packet";
+    return false;
+  }
+  RTCPHelp::RTCPPacketInformation rtcp_packet_information;
+  IncomingRTCPPacket(rtcp_packet_information, &rtcp_parser);
+  TriggerCallbacksFromRTCPPacket(rtcp_packet_information);
+  return true;
+}
+
 int64_t RTCPReceiver::LastReceived() {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   return _lastReceived;
 }
 
 int64_t RTCPReceiver::LastReceivedReceiverReport() const {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   int64_t last_received_rr = -1;
   for (ReceivedInfoMap::const_iterator it = _receivedInfoMap.begin();
        it != _receivedInfoMap.end(); ++it) {
@@ skipping 1256 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