Adjust RtcpReceiver to be testable with callbacks:

webrtc/modules/rtp_rtcp/source/rtcp_receiver.h

 /*
  *  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.
  */
 
 #ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_RECEIVER_H_
 #define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_RECEIVER_H_
 
+#include <list>
 #include <map>
 #include <set>
 #include <vector>
 
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/thread_annotations.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
-#include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
-class ModuleRtpRtcpImpl;
+namespace rtcp {
+class TmmbItem;
+}  // namespace rtcp
 
 class RTCPReceiver {
  public:
+  class SenderCallbacks {

[philipel, 2016/08/24 13:50:26]

I think this name is a bit ambiguous. Maybe call it RTCPReceiver::Callbacks or
RTCPReceiver::RtcpReceivedCallbacks or something like that.

[danilchap, 2016/08/26 11:47:51]

Can agree name is ambigous, SenderCallbacks sounds like it is callbacks from
sender not for sender.
Just Callbacks feel too generic, it like having no name.
RtcpReceiver::RtcpReceivedCallbacks - both redundant and generic.

What about just 'Sender'. Feels ok, or should I rethink?
(this 4 function are either for rtp_sender or for rtcp_sender).

+   public:
+    virtual void SetTmmbn(std::vector<rtcp::TmmbItem> bounding_set) = 0;
+    virtual void OnRequestSendReport() = 0;
+    virtual void OnReceivedNACK(

[philipel, 2016/08/24 13:50:26]

OnReceiverNack

[danilchap, 2016/08/26 11:47:51]

done in separate CL since it is unrelated to this one.

+        const std::list<uint16_t>& nack_sequence_numbers) = 0;

[philipel, 2016/08/24 13:50:26]

If it only requires a small change, use vector instead.

[danilchap, 2016/08/26 11:47:51]

Not that small, done in separate CL since it is unrelated to this one.

+    virtual void OnReceivedRtcpReportBlocks(
+        const ReportBlockList& report_blocks) = 0;
+
+   protected:
+    virtual ~SenderCallbacks() = default;
+  };
+
   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);
+               SenderCallbacks* sender_callbacks);
   virtual ~RTCPReceiver();
 
+  bool IncomingPacket(const uint8_t* packet, size_t packet_size);
+
   int64_t LastReceived();
   int64_t LastReceivedReceiverReport() const;
 
   void SetSsrcs(uint32_t main_ssrc, const std::set<uint32_t>& registered_ssrcs);
   void SetRemoteSSRC(uint32_t ssrc);
   uint32_t RemoteSSRC() const;
 
   int32_t IncomingRTCPPacket(
       RTCPHelp::RTCPPacketInformation& rtcpPacketInformation,
       RTCPUtility::RTCPParserV2* rtcpParser);
@@ skipping 200 matching lines @@
       uint32_t source_ssrc)
       EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
   RTCPHelp::RTCPReportBlockInformation* GetReportBlockInformation(
       uint32_t remote_ssrc,
       uint32_t source_ssrc) const
       EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
 
   Clock* const _clock;
   const bool receiver_only_;
   int64_t _lastReceived;
-  ModuleRtpRtcpImpl& _rtpRtcp;
+  SenderCallbacks& _rtpRtcp;
 
   rtc::CriticalSection _criticalSectionFeedbacks;
   RtcpBandwidthObserver* const _cbRtcpBandwidthObserver;
   RtcpIntraFrameObserver* const _cbRtcpIntraFrameObserver;
   TransportFeedbackObserver* const _cbTransportFeedbackObserver;
 
   rtc::CriticalSection _criticalSectionRTCPReceiver;
   uint32_t main_ssrc_ GUARDED_BY(_criticalSectionRTCPReceiver);
   uint32_t _remoteSSRC GUARDED_BY(_criticalSectionRTCPReceiver);
   std::set<uint32_t> registered_ssrcs_ GUARDED_BY(_criticalSectionRTCPReceiver);
@@ skipping 31 matching lines @@
   RtcpPacketTypeCounterObserver* const packet_type_counter_observer_;
   RtcpPacketTypeCounter packet_type_counter_;
 
   RTCPUtility::NackStats nack_stats_;
 
   size_t num_skipped_packets_;
   int64_t last_skipped_packets_warning_;
 };
 }  // namespace webrtc
 #endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_RECEIVER_H_