diff --git a/modules/rtp_rtcp/source/rtcp_receiver.cc b/modules/rtp_rtcp/source/rtcp_receiver.cc index 26465ada40..68e86a22c5 100644 --- a/modules/rtp_rtcp/source/rtcp_receiver.cc +++ b/modules/rtp_rtcp/source/rtcp_receiver.cc @@ -172,14 +172,14 @@ RTCPReceiver::RTCPReceiver(const RtpRtcp::Configuration& config, RTCPReceiver::~RTCPReceiver() {} -void RTCPReceiver::IncomingPacket(const uint8_t* packet, size_t packet_size) { - if (packet_size == 0) { +void RTCPReceiver::IncomingPacket(rtc::ArrayView packet) { + if (packet.empty()) { RTC_LOG(LS_WARNING) << "Incoming empty RTCP packet"; return; } PacketInformation packet_information; - if (!ParseCompoundPacket(packet, packet + packet_size, &packet_information)) + if (!ParseCompoundPacket(packet, &packet_information)) return; TriggerCallbacksFromRtcpPacket(packet_information); } @@ -325,18 +325,17 @@ std::vector RTCPReceiver::GetLatestReportBlockData() const { return result; } -bool RTCPReceiver::ParseCompoundPacket(const uint8_t* packet_begin, - const uint8_t* packet_end, +bool RTCPReceiver::ParseCompoundPacket(rtc::ArrayView packet, PacketInformation* packet_information) { rtc::CritScope lock(&rtcp_receiver_lock_); CommonHeader rtcp_block; - for (const uint8_t* next_block = packet_begin; next_block != packet_end; + 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; + 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) { + if (next_block == packet.begin()) { // Failed to parse 1st header, nothing was extracted from this packet. RTC_LOG(LS_WARNING) << "Incoming invalid RTCP packet"; return false; diff --git a/modules/rtp_rtcp/source/rtcp_receiver.h b/modules/rtp_rtcp/source/rtcp_receiver.h index 5b92d55609..3af43b3e89 100644 --- a/modules/rtp_rtcp/source/rtcp_receiver.h +++ b/modules/rtp_rtcp/source/rtcp_receiver.h @@ -17,6 +17,7 @@ #include #include +#include "api/array_view.h" #include "modules/rtp_rtcp/include/report_block_data.h" #include "modules/rtp_rtcp/include/rtcp_statistics.h" #include "modules/rtp_rtcp/include/rtp_rtcp.h" @@ -37,7 +38,7 @@ class TargetBitrate; class TmmbItem; } // namespace rtcp -class RTCPReceiver { +class RTCPReceiver final { public: class ModuleRtpRtcp { public: @@ -53,9 +54,12 @@ class RTCPReceiver { }; RTCPReceiver(const RtpRtcp::Configuration& config, ModuleRtpRtcp* owner); - virtual ~RTCPReceiver(); + ~RTCPReceiver(); - void IncomingPacket(const uint8_t* packet, size_t packet_size); + void IncomingPacket(const uint8_t* packet, size_t packet_size) { + IncomingPacket(rtc::MakeArrayView(packet, packet_size)); + } + void IncomingPacket(rtc::ArrayView packet); int64_t LastReceivedReportBlockMs() const; @@ -124,8 +128,7 @@ class RTCPReceiver { // RTCP report blocks map mapped by source SSRC. using ReportBlockMap = std::map; - bool ParseCompoundPacket(const uint8_t* packet_begin, - const uint8_t* packet_end, + bool ParseCompoundPacket(rtc::ArrayView packet, PacketInformation* packet_information); void TriggerCallbacksFromRtcpPacket( diff --git a/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc b/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc index fc84507353..30caf7b63c 100644 --- a/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc +++ b/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc @@ -62,59 +62,74 @@ using ::testing::UnorderedElementsAre; class MockRtcpPacketTypeCounterObserver : public RtcpPacketTypeCounterObserver { public: - MOCK_METHOD2(RtcpPacketTypesCounterUpdated, - void(uint32_t, const RtcpPacketTypeCounter&)); + MOCK_METHOD(void, + RtcpPacketTypesCounterUpdated, + (uint32_t, const RtcpPacketTypeCounter&), + (override)); }; class MockRtcpIntraFrameObserver : public RtcpIntraFrameObserver { public: - MOCK_METHOD1(OnReceivedIntraFrameRequest, void(uint32_t)); + MOCK_METHOD(void, OnReceivedIntraFrameRequest, (uint32_t), (override)); }; class MockRtcpLossNotificationObserver : public RtcpLossNotificationObserver { public: ~MockRtcpLossNotificationObserver() override = default; - MOCK_METHOD4(OnReceivedLossNotification, - void(uint32_t ssrc, - uint16_t seq_num_of_last_decodable, - uint16_t seq_num_of_last_received, - bool decodability_flag)); + MOCK_METHOD(void, + OnReceivedLossNotification, + (uint32_t ssrc, + uint16_t seq_num_of_last_decodable, + uint16_t seq_num_of_last_received, + bool decodability_flag), + (override)); }; class MockRtcpCallbackImpl : public RtcpStatisticsCallback { public: - MOCK_METHOD2(StatisticsUpdated, void(const RtcpStatistics&, uint32_t)); + MOCK_METHOD(void, + StatisticsUpdated, + (const RtcpStatistics&, uint32_t), + (override)); }; class MockCnameCallbackImpl : public RtcpCnameCallback { public: - MOCK_METHOD2(OnCname, void(uint32_t, absl::string_view)); + MOCK_METHOD(void, OnCname, (uint32_t, absl::string_view), (override)); }; class MockReportBlockDataObserverImpl : public ReportBlockDataObserver { public: - MOCK_METHOD1(OnReportBlockDataUpdated, void(ReportBlockData)); + MOCK_METHOD(void, OnReportBlockDataUpdated, (ReportBlockData), (override)); }; class MockTransportFeedbackObserver : public TransportFeedbackObserver { public: - MOCK_METHOD1(OnAddPacket, void(const RtpPacketSendInfo&)); - MOCK_METHOD1(OnTransportFeedback, void(const rtcp::TransportFeedback&)); + MOCK_METHOD(void, OnAddPacket, (const RtpPacketSendInfo&), (override)); + MOCK_METHOD(void, + OnTransportFeedback, + (const rtcp::TransportFeedback&), + (override)); }; class MockModuleRtpRtcp : public RTCPReceiver::ModuleRtpRtcp { public: - MOCK_METHOD1(SetTmmbn, void(std::vector)); - MOCK_METHOD0(OnRequestSendReport, void()); - MOCK_METHOD1(OnReceivedNack, void(const std::vector&)); - MOCK_METHOD1(OnReceivedRtcpReportBlocks, void(const ReportBlockList&)); + MOCK_METHOD(void, SetTmmbn, (std::vector), (override)); + MOCK_METHOD(void, OnRequestSendReport, (), (override)); + MOCK_METHOD(void, OnReceivedNack, (const std::vector&), (override)); + MOCK_METHOD(void, + OnReceivedRtcpReportBlocks, + (const ReportBlockList&), + (override)); }; class MockVideoBitrateAllocationObserver : public VideoBitrateAllocationObserver { public: - MOCK_METHOD1(OnBitrateAllocationUpdated, - void(const VideoBitrateAllocation& allocation)); + MOCK_METHOD(void, + OnBitrateAllocationUpdated, + (const VideoBitrateAllocation& allocation), + (override)); }; // SSRC of remote peer, that sends rtcp packet to the rtcp receiver under test. @@ -131,119 +146,116 @@ constexpr int64_t kRtcpIntervalMs = 1000; } // namespace -class RtcpReceiverTest : public ::testing::Test { - protected: - RtcpReceiverTest() - : system_clock_(1335900000), - rtcp_receiver_( - [&] { - RtpRtcp::Configuration config; - config.clock = &system_clock_; - config.receiver_only = false; - config.rtcp_packet_type_counter_observer = - &packet_type_counter_observer_; - config.bandwidth_callback = &bandwidth_observer_; - config.intra_frame_callback = &intra_frame_observer_; - config.rtcp_loss_notification_observer = - &rtcp_loss_notification_observer_; - config.transport_feedback_callback = - &transport_feedback_observer_; - config.bitrate_allocation_observer = - &bitrate_allocation_observer_; - config.rtcp_report_interval_ms = kRtcpIntervalMs; - config.local_media_ssrc = kReceiverMainSsrc; - config.rtx_send_ssrc = kReceiverExtraSsrc; - return config; - }(), - &rtp_rtcp_impl_) {} - void SetUp() { - rtcp_receiver_.SetRemoteSSRC(kSenderSsrc); - } +struct ReceiverMocks { + ReceiverMocks() : clock(1335900000) {} - void InjectRtcpPacket(rtc::ArrayView raw) { - rtcp_receiver_.IncomingPacket(raw.data(), raw.size()); - } - - void InjectRtcpPacket(const rtcp::RtcpPacket& packet) { - rtc::Buffer raw = packet.Build(); - rtcp_receiver_.IncomingPacket(raw.data(), raw.size()); - } - - SimulatedClock system_clock_; + SimulatedClock clock; // Callbacks to packet_type_counter_observer are frequent but most of the time // are not interesting. - NiceMock packet_type_counter_observer_; - StrictMock bandwidth_observer_; - StrictMock intra_frame_observer_; - StrictMock rtcp_loss_notification_observer_; - StrictMock transport_feedback_observer_; - StrictMock bitrate_allocation_observer_; - StrictMock rtp_rtcp_impl_; - - RTCPReceiver rtcp_receiver_; + NiceMock packet_type_counter_observer; + StrictMock bandwidth_observer; + StrictMock intra_frame_observer; + StrictMock rtcp_loss_notification_observer; + StrictMock transport_feedback_observer; + StrictMock bitrate_allocation_observer; + StrictMock rtp_rtcp_impl; }; -TEST_F(RtcpReceiverTest, BrokenPacketIsIgnored) { - const uint8_t bad_packet[] = {0, 0, 0, 0}; - EXPECT_CALL(packet_type_counter_observer_, - RtcpPacketTypesCounterUpdated(_, _)) - .Times(0); - InjectRtcpPacket(bad_packet); +RtpRtcp::Configuration DefaultConfiguration(ReceiverMocks* mocks) { + RtpRtcp::Configuration config; + config.clock = &mocks->clock; + config.receiver_only = false; + config.rtcp_packet_type_counter_observer = + &mocks->packet_type_counter_observer; + config.bandwidth_callback = &mocks->bandwidth_observer; + config.intra_frame_callback = &mocks->intra_frame_observer; + config.rtcp_loss_notification_observer = + &mocks->rtcp_loss_notification_observer; + config.transport_feedback_callback = &mocks->transport_feedback_observer; + config.bitrate_allocation_observer = &mocks->bitrate_allocation_observer; + config.rtcp_report_interval_ms = kRtcpIntervalMs; + config.local_media_ssrc = kReceiverMainSsrc; + config.rtx_send_ssrc = kReceiverExtraSsrc; + return config; } -TEST_F(RtcpReceiverTest, InvalidFeedbackPacketIsIgnored) { +TEST(RtcpReceiverTest, BrokenPacketIsIgnored) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + + const uint8_t bad_packet[] = {0, 0, 0, 0}; + EXPECT_CALL(mocks.packet_type_counter_observer, RtcpPacketTypesCounterUpdated) + .Times(0); + receiver.IncomingPacket(bad_packet); +} + +TEST(RtcpReceiverTest, InvalidFeedbackPacketIsIgnored) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + // Too short feedback packet. const uint8_t bad_packet[] = {0x81, rtcp::Rtpfb::kPacketType, 0, 0}; // TODO(danilchap): Add expectation RtcpPacketTypesCounterUpdated // is not called once parser would be adjusted to avoid that callback on // semi-valid packets. - InjectRtcpPacket(bad_packet); + receiver.IncomingPacket(bad_packet); } -TEST_F(RtcpReceiverTest, InjectSrPacket) { - EXPECT_FALSE(rtcp_receiver_.NTP(nullptr, nullptr, nullptr, nullptr, nullptr)); +TEST(RtcpReceiverTest, InjectSrPacket) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); - int64_t now = system_clock_.TimeInMilliseconds(); + EXPECT_FALSE(receiver.NTP(nullptr, nullptr, nullptr, nullptr, nullptr)); + + int64_t now = mocks.clock.TimeInMilliseconds(); rtcp::SenderReport sr; sr.SetSenderSsrc(kSenderSsrc); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty())); - EXPECT_CALL(bandwidth_observer_, + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks(IsEmpty())); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport(IsEmpty(), _, now)); - InjectRtcpPacket(sr); + receiver.IncomingPacket(sr.Build()); - EXPECT_TRUE(rtcp_receiver_.NTP(nullptr, nullptr, nullptr, nullptr, nullptr)); + EXPECT_TRUE(receiver.NTP(nullptr, nullptr, nullptr, nullptr, nullptr)); } -TEST_F(RtcpReceiverTest, InjectSrPacketFromUnknownSender) { - int64_t now = system_clock_.TimeInMilliseconds(); +TEST(RtcpReceiverTest, InjectSrPacketFromUnknownSender) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + + int64_t now = mocks.clock.TimeInMilliseconds(); rtcp::SenderReport sr; sr.SetSenderSsrc(kUnknownSenderSsrc); // The parser will handle report blocks in Sender Report from other than his // expected peer. - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); - EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, now)); - InjectRtcpPacket(sr); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks); + EXPECT_CALL(mocks.bandwidth_observer, + OnReceivedRtcpReceiverReport(_, _, now)); + receiver.IncomingPacket(sr.Build()); // But will not flag that he's gotten sender information. - EXPECT_FALSE(rtcp_receiver_.NTP(nullptr, nullptr, nullptr, nullptr, nullptr)); + EXPECT_FALSE(receiver.NTP(nullptr, nullptr, nullptr, nullptr, nullptr)); } -TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesRTT) { - Random r(0x0123456789abcdef); - const int64_t kRttMs = r.Rand(1, 9 * 3600 * 1000); - const uint32_t kDelayNtp = r.Rand(0, 0x7fffffff); +TEST(RtcpReceiverTest, InjectSrPacketCalculatesRTT) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + + const int64_t kRttMs = 123; + const uint32_t kDelayNtp = 0x4321; const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp); int64_t rtt_ms = 0; - EXPECT_EQ( - -1, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); + EXPECT_EQ(-1, receiver.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); uint32_t sent_ntp = - CompactNtp(TimeMicrosToNtp(system_clock_.TimeInMicroseconds())); - system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); + CompactNtp(TimeMicrosToNtp(mocks.clock.TimeInMicroseconds())); + mocks.clock.AdvanceTimeMilliseconds(kRttMs + kDelayMs); rtcp::SenderReport sr; sr.SetSenderSsrc(kSenderSsrc); @@ -253,28 +265,29 @@ TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesRTT) { block.SetDelayLastSr(kDelayNtp); sr.AddReportBlock(block); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); - EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); - InjectRtcpPacket(sr); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport); + receiver.IncomingPacket(sr.Build()); - EXPECT_EQ( - 0, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); + EXPECT_EQ(0, receiver.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); EXPECT_NEAR(kRttMs, rtt_ms, 1); } -TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesNegativeRTTAsOne) { - Random r(0x0123456789abcdef); - const int64_t kRttMs = r.Rand(-3600 * 1000, -1); - const uint32_t kDelayNtp = r.Rand(0, 0x7fffffff); +TEST(RtcpReceiverTest, InjectSrPacketCalculatesNegativeRTTAsOne) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + + const int64_t kRttMs = -13; + const uint32_t kDelayNtp = 0x4321; const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp); int64_t rtt_ms = 0; - EXPECT_EQ( - -1, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); + EXPECT_EQ(-1, receiver.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); uint32_t sent_ntp = - CompactNtp(TimeMicrosToNtp(system_clock_.TimeInMicroseconds())); - system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); + CompactNtp(TimeMicrosToNtp(mocks.clock.TimeInMicroseconds())); + mocks.clock.AdvanceTimeMilliseconds(kRttMs + kDelayMs); rtcp::SenderReport sr; sr.SetSenderSsrc(kSenderSsrc); @@ -284,26 +297,28 @@ TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesNegativeRTTAsOne) { block.SetDelayLastSr(kDelayNtp); sr.AddReportBlock(block); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1))); - EXPECT_CALL(bandwidth_observer_, + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks(SizeIs(1))); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport(SizeIs(1), _, _)); - InjectRtcpPacket(sr); + receiver.IncomingPacket(sr.Build()); - EXPECT_EQ( - 0, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); + EXPECT_EQ(0, receiver.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); EXPECT_EQ(1, rtt_ms); } -TEST_F( - RtcpReceiverTest, - TwoReportBlocksWithLastOneWithoutLastSrCalculatesRttForBandwidthObserver) { +TEST(RtcpReceiverTest, + TwoReportBlocksWithLastOneWithoutLastSrCalculatesRttForBandwidthObserver) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + const int64_t kRttMs = 120; const uint32_t kDelayNtp = 123000; const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp); uint32_t sent_ntp = - CompactNtp(TimeMicrosToNtp(system_clock_.TimeInMicroseconds())); - system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); + CompactNtp(TimeMicrosToNtp(mocks.clock.TimeInMicroseconds())); + mocks.clock.AdvanceTimeMilliseconds(kRttMs + kDelayMs); rtcp::SenderReport sr; sr.SetSenderSsrc(kSenderSsrc); @@ -316,48 +331,60 @@ TEST_F( block.SetLastSr(0); sr.AddReportBlock(block); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(2))); - EXPECT_CALL(bandwidth_observer_, + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks(SizeIs(2))); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport(SizeIs(2), kRttMs, _)); - InjectRtcpPacket(sr); + receiver.IncomingPacket(sr.Build()); } -TEST_F(RtcpReceiverTest, InjectRrPacket) { - int64_t now = system_clock_.TimeInMilliseconds(); +TEST(RtcpReceiverTest, InjectRrPacket) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + + int64_t now = mocks.clock.TimeInMilliseconds(); rtcp::ReceiverReport rr; rr.SetSenderSsrc(kSenderSsrc); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty())); - EXPECT_CALL(bandwidth_observer_, + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks(IsEmpty())); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport(IsEmpty(), _, now)); - InjectRtcpPacket(rr); + receiver.IncomingPacket(rr.Build()); std::vector report_blocks; - rtcp_receiver_.StatisticsReceived(&report_blocks); + receiver.StatisticsReceived(&report_blocks); EXPECT_TRUE(report_blocks.empty()); } -TEST_F(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) { - int64_t now = system_clock_.TimeInMilliseconds(); +TEST(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + + int64_t now = mocks.clock.TimeInMilliseconds(); rtcp::ReportBlock rb; rb.SetMediaSsrc(kNotToUsSsrc); rtcp::ReceiverReport rr; rr.SetSenderSsrc(kSenderSsrc); rr.AddReportBlock(rb); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty())); - EXPECT_CALL(bandwidth_observer_, + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks(IsEmpty())); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport(IsEmpty(), _, now)); - InjectRtcpPacket(rr); + receiver.IncomingPacket(rr.Build()); - EXPECT_EQ(0, rtcp_receiver_.LastReceivedReportBlockMs()); + EXPECT_EQ(0, receiver.LastReceivedReportBlockMs()); std::vector received_blocks; - rtcp_receiver_.StatisticsReceived(&received_blocks); + receiver.StatisticsReceived(&received_blocks); EXPECT_TRUE(received_blocks.empty()); } -TEST_F(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) { - int64_t now = system_clock_.TimeInMilliseconds(); +TEST(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + + int64_t now = mocks.clock.TimeInMilliseconds(); rtcp::ReportBlock rb; rb.SetMediaSsrc(kReceiverMainSsrc); @@ -365,19 +392,23 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) { rr.SetSenderSsrc(kSenderSsrc); rr.AddReportBlock(rb); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1))); - EXPECT_CALL(bandwidth_observer_, + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks(SizeIs(1))); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport(SizeIs(1), _, now)); - InjectRtcpPacket(rr); + receiver.IncomingPacket(rr.Build()); - EXPECT_EQ(now, rtcp_receiver_.LastReceivedReportBlockMs()); + EXPECT_EQ(now, receiver.LastReceivedReportBlockMs()); std::vector received_blocks; - rtcp_receiver_.StatisticsReceived(&received_blocks); + receiver.StatisticsReceived(&received_blocks); EXPECT_EQ(1u, received_blocks.size()); } -TEST_F(RtcpReceiverTest, InjectSrPacketWithOneReportBlock) { - int64_t now = system_clock_.TimeInMilliseconds(); +TEST(RtcpReceiverTest, InjectSrPacketWithOneReportBlock) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + + int64_t now = mocks.clock.TimeInMilliseconds(); rtcp::ReportBlock rb; rb.SetMediaSsrc(kReceiverMainSsrc); @@ -385,22 +416,26 @@ TEST_F(RtcpReceiverTest, InjectSrPacketWithOneReportBlock) { sr.SetSenderSsrc(kSenderSsrc); sr.AddReportBlock(rb); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1))); - EXPECT_CALL(bandwidth_observer_, + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks(SizeIs(1))); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport(SizeIs(1), _, now)); - InjectRtcpPacket(sr); + receiver.IncomingPacket(sr.Build()); - EXPECT_EQ(now, rtcp_receiver_.LastReceivedReportBlockMs()); + EXPECT_EQ(now, receiver.LastReceivedReportBlockMs()); std::vector received_blocks; - rtcp_receiver_.StatisticsReceived(&received_blocks); + receiver.StatisticsReceived(&received_blocks); EXPECT_EQ(1u, received_blocks.size()); } -TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) { +TEST(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) { const uint16_t kSequenceNumbers[] = {10, 12423}; const uint32_t kCumLost[] = {13, 555}; const uint8_t kFracLost[] = {20, 11}; - int64_t now = system_clock_.TimeInMilliseconds(); + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + + int64_t now = mocks.clock.TimeInMilliseconds(); rtcp::ReportBlock rb1; rb1.SetMediaSsrc(kReceiverMainSsrc); @@ -417,14 +452,14 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) { rr1.AddReportBlock(rb1); rr1.AddReportBlock(rb2); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(2))); - EXPECT_CALL(bandwidth_observer_, + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks(SizeIs(2))); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport(SizeIs(2), _, now)); - InjectRtcpPacket(rr1); + receiver.IncomingPacket(rr1.Build()); - EXPECT_EQ(now, rtcp_receiver_.LastReceivedReportBlockMs()); + EXPECT_EQ(now, receiver.LastReceivedReportBlockMs()); std::vector received_blocks; - rtcp_receiver_.StatisticsReceived(&received_blocks); + receiver.StatisticsReceived(&received_blocks); EXPECT_THAT(received_blocks, UnorderedElementsAre(Field(&RTCPReportBlock::fraction_lost, 0), Field(&RTCPReportBlock::fraction_lost, 10))); @@ -448,16 +483,16 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) { rr2.AddReportBlock(rb4); // Advance time to make 1st sent time and 2nd sent time different. - system_clock_.AdvanceTimeMilliseconds(500); - now = system_clock_.TimeInMilliseconds(); + mocks.clock.AdvanceTimeMilliseconds(500); + now = mocks.clock.TimeInMilliseconds(); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(2))); - EXPECT_CALL(bandwidth_observer_, + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks(SizeIs(2))); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport(SizeIs(2), _, now)); - InjectRtcpPacket(rr2); + receiver.IncomingPacket(rr2.Build()); received_blocks.clear(); - rtcp_receiver_.StatisticsReceived(&received_blocks); + receiver.StatisticsReceived(&received_blocks); EXPECT_EQ(2u, received_blocks.size()); EXPECT_THAT( received_blocks, @@ -474,11 +509,14 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) { kSequenceNumbers[1])))); } -TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) { +TEST(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) { const uint32_t kSenderSsrc2 = 0x20304; const uint16_t kSequenceNumbers[] = {10, 12423}; const int32_t kCumLost[] = {13, 555}; const uint8_t kFracLost[] = {20, 11}; + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); rtcp::ReportBlock rb1; rb1.SetMediaSsrc(kReceiverMainSsrc); @@ -489,17 +527,17 @@ TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) { rr1.SetSenderSsrc(kSenderSsrc); rr1.AddReportBlock(rb1); - int64_t now = system_clock_.TimeInMilliseconds(); + int64_t now = mocks.clock.TimeInMilliseconds(); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1))); - EXPECT_CALL(bandwidth_observer_, + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks(SizeIs(1))); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport(SizeIs(1), _, now)); - InjectRtcpPacket(rr1); + receiver.IncomingPacket(rr1.Build()); - EXPECT_EQ(now, rtcp_receiver_.LastReceivedReportBlockMs()); + EXPECT_EQ(now, receiver.LastReceivedReportBlockMs()); std::vector received_blocks; - rtcp_receiver_.StatisticsReceived(&received_blocks); + receiver.StatisticsReceived(&received_blocks); EXPECT_EQ(1u, received_blocks.size()); EXPECT_EQ(kSenderSsrc, received_blocks[0].sender_ssrc); EXPECT_EQ(kReceiverMainSsrc, received_blocks[0].source_ssrc); @@ -517,13 +555,13 @@ TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) { rr2.SetSenderSsrc(kSenderSsrc2); rr2.AddReportBlock(rb2); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1))); - EXPECT_CALL(bandwidth_observer_, + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks(SizeIs(1))); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport(SizeIs(1), _, now)); - InjectRtcpPacket(rr2); + receiver.IncomingPacket(rr2.Build()); received_blocks.clear(); - rtcp_receiver_.StatisticsReceived(&received_blocks); + receiver.StatisticsReceived(&received_blocks); ASSERT_EQ(2u, received_blocks.size()); EXPECT_THAT( received_blocks, @@ -542,12 +580,15 @@ TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) { kSequenceNumbers[1])))); } -TEST_F(RtcpReceiverTest, GetRtt) { +TEST(RtcpReceiverTest, GetRtt) { const uint32_t kSentCompactNtp = 0x1234; const uint32_t kDelayCompactNtp = 0x222; + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + // No report block received. - EXPECT_EQ( - -1, rtcp_receiver_.RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr)); + EXPECT_EQ(-1, receiver.RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr)); rtcp::ReportBlock rb; rb.SetMediaSsrc(kReceiverMainSsrc); @@ -557,69 +598,88 @@ TEST_F(RtcpReceiverTest, GetRtt) { rtcp::ReceiverReport rr; rr.SetSenderSsrc(kSenderSsrc); rr.AddReportBlock(rb); - int64_t now = system_clock_.TimeInMilliseconds(); + int64_t now = mocks.clock.TimeInMilliseconds(); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); - EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); - InjectRtcpPacket(rr); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport); + receiver.IncomingPacket(rr.Build()); - EXPECT_EQ(now, rtcp_receiver_.LastReceivedReportBlockMs()); - EXPECT_EQ( - 0, rtcp_receiver_.RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr)); + EXPECT_EQ(now, receiver.LastReceivedReportBlockMs()); + EXPECT_EQ(0, receiver.RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr)); } // Ij packets are ignored. -TEST_F(RtcpReceiverTest, InjectIjWithNoItem) { +TEST(RtcpReceiverTest, InjectIjWithNoItem) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + rtcp::ExtendedJitterReport ij; - InjectRtcpPacket(ij); + receiver.IncomingPacket(ij.Build()); } // App packets are ignored. -TEST_F(RtcpReceiverTest, InjectApp) { +TEST(RtcpReceiverTest, InjectApp) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + rtcp::App app; app.SetSubType(30); app.SetName(0x17a177e); const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'}; app.SetData(kData, sizeof(kData)); - InjectRtcpPacket(app); + receiver.IncomingPacket(app.Build()); } -TEST_F(RtcpReceiverTest, InjectSdesWithOneChunk) { +TEST(RtcpReceiverTest, InjectSdesWithOneChunk) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + const char kCname[] = "alice@host"; MockCnameCallbackImpl callback; - rtcp_receiver_.RegisterRtcpCnameCallback(&callback); + receiver.RegisterRtcpCnameCallback(&callback); rtcp::Sdes sdes; sdes.AddCName(kSenderSsrc, kCname); EXPECT_CALL(callback, OnCname(kSenderSsrc, StrEq(kCname))); - InjectRtcpPacket(sdes); + receiver.IncomingPacket(sdes.Build()); char cName[RTCP_CNAME_SIZE]; - EXPECT_EQ(0, rtcp_receiver_.CNAME(kSenderSsrc, cName)); + EXPECT_EQ(0, receiver.CNAME(kSenderSsrc, cName)); EXPECT_EQ(0, strncmp(cName, kCname, RTCP_CNAME_SIZE)); } -TEST_F(RtcpReceiverTest, InjectByePacket_RemovesCname) { +TEST(RtcpReceiverTest, InjectByePacket_RemovesCname) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + const char kCname[] = "alice@host"; rtcp::Sdes sdes; sdes.AddCName(kSenderSsrc, kCname); - InjectRtcpPacket(sdes); + receiver.IncomingPacket(sdes.Build()); char cName[RTCP_CNAME_SIZE]; - EXPECT_EQ(0, rtcp_receiver_.CNAME(kSenderSsrc, cName)); + EXPECT_EQ(0, receiver.CNAME(kSenderSsrc, cName)); // Verify that BYE removes the CNAME. rtcp::Bye bye; bye.SetSenderSsrc(kSenderSsrc); - InjectRtcpPacket(bye); + receiver.IncomingPacket(bye.Build()); - EXPECT_EQ(-1, rtcp_receiver_.CNAME(kSenderSsrc, cName)); + EXPECT_EQ(-1, receiver.CNAME(kSenderSsrc, cName)); } -TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) { +TEST(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + rtcp::ReportBlock rb1; rb1.SetMediaSsrc(kReceiverMainSsrc); rtcp::ReportBlock rb2; @@ -629,103 +689,131 @@ TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) { rr.AddReportBlock(rb1); rr.AddReportBlock(rb2); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); - EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); - InjectRtcpPacket(rr); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport); + receiver.IncomingPacket(rr.Build()); std::vector received_blocks; - rtcp_receiver_.StatisticsReceived(&received_blocks); + receiver.StatisticsReceived(&received_blocks); EXPECT_EQ(2u, received_blocks.size()); // Verify that BYE removes the report blocks. rtcp::Bye bye; bye.SetSenderSsrc(kSenderSsrc); - InjectRtcpPacket(bye); + receiver.IncomingPacket(bye.Build()); received_blocks.clear(); - rtcp_receiver_.StatisticsReceived(&received_blocks); + receiver.StatisticsReceived(&received_blocks); EXPECT_TRUE(received_blocks.empty()); // Inject packet again. - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); - EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); - InjectRtcpPacket(rr); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport); + receiver.IncomingPacket(rr.Build()); received_blocks.clear(); - rtcp_receiver_.StatisticsReceived(&received_blocks); + receiver.StatisticsReceived(&received_blocks); EXPECT_EQ(2u, received_blocks.size()); } -TEST_F(RtcpReceiverTest, InjectByePacketRemovesReferenceTimeInfo) { +TEST(RtcpReceiverTest, InjectByePacketRemovesReferenceTimeInfo) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + rtcp::ExtendedReports xr; xr.SetSenderSsrc(kSenderSsrc); rtcp::Rrtr rrtr; rrtr.SetNtp(NtpTime(0x10203, 0x40506)); xr.SetRrtr(rrtr); - InjectRtcpPacket(xr); + receiver.IncomingPacket(xr.Build()); rtcp::Bye bye; bye.SetSenderSsrc(kSenderSsrc); - InjectRtcpPacket(bye); + receiver.IncomingPacket(bye.Build()); - EXPECT_THAT(rtcp_receiver_.ConsumeReceivedXrReferenceTimeInfo(), IsEmpty()); + EXPECT_THAT(receiver.ConsumeReceivedXrReferenceTimeInfo(), IsEmpty()); } -TEST_F(RtcpReceiverTest, InjectPliPacket) { +TEST(RtcpReceiverTest, InjectPliPacket) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + rtcp::Pli pli; pli.SetMediaSsrc(kReceiverMainSsrc); EXPECT_CALL( - packet_type_counter_observer_, + mocks.packet_type_counter_observer, RtcpPacketTypesCounterUpdated( kReceiverMainSsrc, Field(&RtcpPacketTypeCounter::pli_packets, 1))); - EXPECT_CALL(intra_frame_observer_, + EXPECT_CALL(mocks.intra_frame_observer, OnReceivedIntraFrameRequest(kReceiverMainSsrc)); - InjectRtcpPacket(pli); + receiver.IncomingPacket(pli.Build()); } -TEST_F(RtcpReceiverTest, PliPacketNotToUsIgnored) { +TEST(RtcpReceiverTest, PliPacketNotToUsIgnored) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + rtcp::Pli pli; pli.SetMediaSsrc(kNotToUsSsrc); EXPECT_CALL( - packet_type_counter_observer_, + mocks.packet_type_counter_observer, RtcpPacketTypesCounterUpdated( kReceiverMainSsrc, Field(&RtcpPacketTypeCounter::pli_packets, 0))); - EXPECT_CALL(intra_frame_observer_, OnReceivedIntraFrameRequest(_)).Times(0); - InjectRtcpPacket(pli); + EXPECT_CALL(mocks.intra_frame_observer, OnReceivedIntraFrameRequest).Times(0); + receiver.IncomingPacket(pli.Build()); } -TEST_F(RtcpReceiverTest, InjectFirPacket) { +TEST(RtcpReceiverTest, InjectFirPacket) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + rtcp::Fir fir; fir.AddRequestTo(kReceiverMainSsrc, 13); EXPECT_CALL( - packet_type_counter_observer_, + mocks.packet_type_counter_observer, RtcpPacketTypesCounterUpdated( kReceiverMainSsrc, Field(&RtcpPacketTypeCounter::fir_packets, 1))); - EXPECT_CALL(intra_frame_observer_, + EXPECT_CALL(mocks.intra_frame_observer, OnReceivedIntraFrameRequest(kReceiverMainSsrc)); - InjectRtcpPacket(fir); + receiver.IncomingPacket(fir.Build()); } -TEST_F(RtcpReceiverTest, FirPacketNotToUsIgnored) { +TEST(RtcpReceiverTest, FirPacketNotToUsIgnored) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + rtcp::Fir fir; fir.AddRequestTo(kNotToUsSsrc, 13); - EXPECT_CALL(intra_frame_observer_, OnReceivedIntraFrameRequest(_)).Times(0); - InjectRtcpPacket(fir); + EXPECT_CALL(mocks.intra_frame_observer, OnReceivedIntraFrameRequest).Times(0); + receiver.IncomingPacket(fir.Build()); } -TEST_F(RtcpReceiverTest, ExtendedReportsPacketWithZeroReportBlocksIgnored) { +TEST(RtcpReceiverTest, ExtendedReportsPacketWithZeroReportBlocksIgnored) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + rtcp::ExtendedReports xr; xr.SetSenderSsrc(kSenderSsrc); - InjectRtcpPacket(xr); + receiver.IncomingPacket(xr.Build()); } -TEST_F(RtcpReceiverTest, InjectExtendedReportsReceiverReferenceTimePacket) { +TEST(RtcpReceiverTest, InjectExtendedReportsReceiverReferenceTimePacket) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + const NtpTime kNtp(0x10203, 0x40506); rtcp::Rrtr rrtr; rrtr.SetNtp(kNtp); @@ -734,56 +822,68 @@ TEST_F(RtcpReceiverTest, InjectExtendedReportsReceiverReferenceTimePacket) { xr.SetRrtr(rrtr); std::vector last_xr_rtis = - rtcp_receiver_.ConsumeReceivedXrReferenceTimeInfo(); + receiver.ConsumeReceivedXrReferenceTimeInfo(); EXPECT_THAT(last_xr_rtis, IsEmpty()); - InjectRtcpPacket(xr); + receiver.IncomingPacket(xr.Build()); - last_xr_rtis = rtcp_receiver_.ConsumeReceivedXrReferenceTimeInfo(); + last_xr_rtis = receiver.ConsumeReceivedXrReferenceTimeInfo(); ASSERT_THAT(last_xr_rtis, SizeIs(1)); EXPECT_EQ(kSenderSsrc, last_xr_rtis[0].ssrc); EXPECT_EQ(CompactNtp(kNtp), last_xr_rtis[0].last_rr); EXPECT_EQ(0U, last_xr_rtis[0].delay_since_last_rr); } -TEST_F(RtcpReceiverTest, ExtendedReportsDlrrPacketNotToUsIgnored) { +TEST(RtcpReceiverTest, ExtendedReportsDlrrPacketNotToUsIgnored) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + // Allow calculate rtt using dlrr/rrtr, simulating media receiver side. - rtcp_receiver_.SetRtcpXrRrtrStatus(true); + receiver.SetRtcpXrRrtrStatus(true); rtcp::ExtendedReports xr; xr.SetSenderSsrc(kSenderSsrc); xr.AddDlrrItem(ReceiveTimeInfo(kNotToUsSsrc, 0x12345, 0x67890)); - InjectRtcpPacket(xr); + receiver.IncomingPacket(xr.Build()); int64_t rtt_ms = 0; - EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); + EXPECT_FALSE(receiver.GetAndResetXrRrRtt(&rtt_ms)); } -TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) { +TEST(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + const uint32_t kLastRR = 0x12345; const uint32_t kDelay = 0x23456; - rtcp_receiver_.SetRtcpXrRrtrStatus(true); + receiver.SetRtcpXrRrtrStatus(true); int64_t rtt_ms = 0; - EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); + EXPECT_FALSE(receiver.GetAndResetXrRrRtt(&rtt_ms)); rtcp::ExtendedReports xr; xr.SetSenderSsrc(kSenderSsrc); xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, kLastRR, kDelay)); - InjectRtcpPacket(xr); + receiver.IncomingPacket(xr.Build()); uint32_t compact_ntp_now = - CompactNtp(TimeMicrosToNtp(system_clock_.TimeInMicroseconds())); - EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); + CompactNtp(TimeMicrosToNtp(mocks.clock.TimeInMicroseconds())); + EXPECT_TRUE(receiver.GetAndResetXrRrRtt(&rtt_ms)); uint32_t rtt_ntp = compact_ntp_now - kDelay - kLastRR; EXPECT_NEAR(CompactNtpRttToMs(rtt_ntp), rtt_ms, 1); } -TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) { +TEST(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + const uint32_t kLastRR = 0x12345; const uint32_t kDelay = 0x56789; - rtcp_receiver_.SetRtcpXrRrtrStatus(true); + receiver.SetRtcpXrRrtrStatus(true); rtcp::ExtendedReports xr; xr.SetSenderSsrc(kSenderSsrc); @@ -791,18 +891,22 @@ TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) { xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc + 1, 0x12345, 0x67890)); xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc + 2, 0x12345, 0x67890)); - InjectRtcpPacket(xr); + receiver.IncomingPacket(xr.Build()); uint32_t compact_ntp_now = - CompactNtp(TimeMicrosToNtp(system_clock_.TimeInMicroseconds())); + CompactNtp(TimeMicrosToNtp(mocks.clock.TimeInMicroseconds())); int64_t rtt_ms = 0; - EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); + EXPECT_TRUE(receiver.GetAndResetXrRrRtt(&rtt_ms)); uint32_t rtt_ntp = compact_ntp_now - kDelay - kLastRR; EXPECT_NEAR(CompactNtpRttToMs(rtt_ntp), rtt_ms, 1); } -TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) { - rtcp_receiver_.SetRtcpXrRrtrStatus(true); +TEST(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + + receiver.SetRtcpXrRrtrStatus(true); rtcp::Rrtr rrtr; rtcp::ExtendedReports xr; @@ -810,17 +914,21 @@ TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) { xr.SetRrtr(rrtr); xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, 0x12345, 0x67890)); - InjectRtcpPacket(xr); + receiver.IncomingPacket(xr.Build()); std::vector last_xr_rtis = - rtcp_receiver_.ConsumeReceivedXrReferenceTimeInfo(); + receiver.ConsumeReceivedXrReferenceTimeInfo(); EXPECT_THAT(last_xr_rtis, SizeIs(1)); int64_t rtt_ms = 0; - EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); + EXPECT_TRUE(receiver.GetAndResetXrRrRtt(&rtt_ms)); } -TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) { - rtcp_receiver_.SetRtcpXrRrtrStatus(true); +TEST(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + + receiver.SetRtcpXrRrtrStatus(true); rtcp::Rrtr rrtr; rtcp::ExtendedReports xr; @@ -832,71 +940,91 @@ TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) { // Modify the DLRR block to have an unsupported block type, from 5 to 6. ASSERT_EQ(5, packet.data()[20]); packet.data()[20] = 6; - InjectRtcpPacket(packet); + receiver.IncomingPacket(packet); // Validate Rrtr was received and processed. std::vector last_xr_rtis = - rtcp_receiver_.ConsumeReceivedXrReferenceTimeInfo(); + receiver.ConsumeReceivedXrReferenceTimeInfo(); EXPECT_THAT(last_xr_rtis, SizeIs(1)); // Validate Dlrr report wasn't processed. int64_t rtt_ms = 0; - EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); + EXPECT_FALSE(receiver.GetAndResetXrRrRtt(&rtt_ms)); } -TEST_F(RtcpReceiverTest, TestExtendedReportsRrRttInitiallyFalse) { - rtcp_receiver_.SetRtcpXrRrtrStatus(true); +TEST(RtcpReceiverTest, TestExtendedReportsRrRttInitiallyFalse) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + + receiver.SetRtcpXrRrtrStatus(true); int64_t rtt_ms; - EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); + EXPECT_FALSE(receiver.GetAndResetXrRrRtt(&rtt_ms)); } -TEST_F(RtcpReceiverTest, RttCalculatedAfterExtendedReportsDlrr) { +TEST(RtcpReceiverTest, RttCalculatedAfterExtendedReportsDlrr) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + Random rand(0x0123456789abcdef); const int64_t kRttMs = rand.Rand(1, 9 * 3600 * 1000); const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff); const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp); - rtcp_receiver_.SetRtcpXrRrtrStatus(true); - NtpTime now = TimeMicrosToNtp(system_clock_.TimeInMicroseconds()); + receiver.SetRtcpXrRrtrStatus(true); + NtpTime now = TimeMicrosToNtp(mocks.clock.TimeInMicroseconds()); uint32_t sent_ntp = CompactNtp(now); - system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); + mocks.clock.AdvanceTimeMilliseconds(kRttMs + kDelayMs); rtcp::ExtendedReports xr; xr.SetSenderSsrc(kSenderSsrc); xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, sent_ntp, kDelayNtp)); - InjectRtcpPacket(xr); + receiver.IncomingPacket(xr.Build()); int64_t rtt_ms = 0; - EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); + EXPECT_TRUE(receiver.GetAndResetXrRrRtt(&rtt_ms)); EXPECT_NEAR(kRttMs, rtt_ms, 1); } -TEST_F(RtcpReceiverTest, XrDlrrCalculatesNegativeRttAsOne) { +TEST(RtcpReceiverTest, XrDlrrCalculatesNegativeRttAsOne) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + Random rand(0x0123456789abcdef); const int64_t kRttMs = rand.Rand(-3600 * 1000, -1); const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff); const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp); - NtpTime now = TimeMicrosToNtp(system_clock_.TimeInMicroseconds()); + NtpTime now = TimeMicrosToNtp(mocks.clock.TimeInMicroseconds()); uint32_t sent_ntp = CompactNtp(now); - system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); - rtcp_receiver_.SetRtcpXrRrtrStatus(true); + mocks.clock.AdvanceTimeMilliseconds(kRttMs + kDelayMs); + receiver.SetRtcpXrRrtrStatus(true); rtcp::ExtendedReports xr; xr.SetSenderSsrc(kSenderSsrc); xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, sent_ntp, kDelayNtp)); - InjectRtcpPacket(xr); + receiver.IncomingPacket(xr.Build()); int64_t rtt_ms = 0; - EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); + EXPECT_TRUE(receiver.GetAndResetXrRrRtt(&rtt_ms)); EXPECT_EQ(1, rtt_ms); } -TEST_F(RtcpReceiverTest, ConsumeReceivedXrReferenceTimeInfoInitiallyEmpty) { - EXPECT_THAT(rtcp_receiver_.ConsumeReceivedXrReferenceTimeInfo(), IsEmpty()); +TEST(RtcpReceiverTest, ConsumeReceivedXrReferenceTimeInfoInitiallyEmpty) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + + EXPECT_THAT(receiver.ConsumeReceivedXrReferenceTimeInfo(), IsEmpty()); } -TEST_F(RtcpReceiverTest, ConsumeReceivedXrReferenceTimeInfo) { +TEST(RtcpReceiverTest, ConsumeReceivedXrReferenceTimeInfo) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + const NtpTime kNtp(0x10203, 0x40506); const uint32_t kNtpMid = CompactNtp(kNtp); @@ -906,20 +1034,24 @@ TEST_F(RtcpReceiverTest, ConsumeReceivedXrReferenceTimeInfo) { xr.SetSenderSsrc(kSenderSsrc); xr.SetRrtr(rrtr); - InjectRtcpPacket(xr); + receiver.IncomingPacket(xr.Build()); - system_clock_.AdvanceTimeMilliseconds(1000); + mocks.clock.AdvanceTimeMilliseconds(1000); std::vector last_xr_rtis = - rtcp_receiver_.ConsumeReceivedXrReferenceTimeInfo(); + receiver.ConsumeReceivedXrReferenceTimeInfo(); ASSERT_THAT(last_xr_rtis, SizeIs(1)); EXPECT_EQ(kSenderSsrc, last_xr_rtis[0].ssrc); EXPECT_EQ(kNtpMid, last_xr_rtis[0].last_rr); EXPECT_EQ(65536U, last_xr_rtis[0].delay_since_last_rr); } -TEST_F(RtcpReceiverTest, - ReceivedRrtrFromSameSsrcUpdatesReceivedReferenceTimeInfo) { +TEST(RtcpReceiverTest, + ReceivedRrtrFromSameSsrcUpdatesReceivedReferenceTimeInfo) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + const NtpTime kNtp1(0x10203, 0x40506); const NtpTime kNtp2(0x11223, 0x44556); const int64_t kDelayMs = 2000; @@ -929,23 +1061,27 @@ TEST_F(RtcpReceiverTest, rtcp::Rrtr rrtr1; rrtr1.SetNtp(kNtp1); xr.SetRrtr(rrtr1); - InjectRtcpPacket(xr); - system_clock_.AdvanceTimeMilliseconds(kDelayMs); + receiver.IncomingPacket(xr.Build()); + mocks.clock.AdvanceTimeMilliseconds(kDelayMs); rtcp::Rrtr rrtr2; rrtr2.SetNtp(kNtp2); xr.SetRrtr(rrtr2); - InjectRtcpPacket(xr); - system_clock_.AdvanceTimeMilliseconds(kDelayMs); + receiver.IncomingPacket(xr.Build()); + mocks.clock.AdvanceTimeMilliseconds(kDelayMs); std::vector last_xr_rtis = - rtcp_receiver_.ConsumeReceivedXrReferenceTimeInfo(); + receiver.ConsumeReceivedXrReferenceTimeInfo(); ASSERT_THAT(last_xr_rtis, SizeIs(1)); EXPECT_EQ(kSenderSsrc, last_xr_rtis[0].ssrc); EXPECT_EQ(CompactNtp(kNtp2), last_xr_rtis[0].last_rr); EXPECT_EQ(kDelayMs * 65536 / 1000, last_xr_rtis[0].delay_since_last_rr); } -TEST_F(RtcpReceiverTest, StoresLastReceivedRrtrPerSsrc) { +TEST(RtcpReceiverTest, StoresLastReceivedRrtrPerSsrc) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + const size_t kNumBufferedReports = 1; const size_t kNumReports = rtcp::ExtendedReports::kMaxNumberOfDlrrItems + kNumBufferedReports; @@ -955,12 +1091,12 @@ TEST_F(RtcpReceiverTest, StoresLastReceivedRrtrPerSsrc) { rtcp::Rrtr rrtr; rrtr.SetNtp(NtpTime(i * 200, i * 300)); xr.SetRrtr(rrtr); - InjectRtcpPacket(xr); - system_clock_.AdvanceTimeMilliseconds(1000); + receiver.IncomingPacket(xr.Build()); + mocks.clock.AdvanceTimeMilliseconds(1000); } std::vector last_xr_rtis = - rtcp_receiver_.ConsumeReceivedXrReferenceTimeInfo(); + receiver.ConsumeReceivedXrReferenceTimeInfo(); ASSERT_THAT(last_xr_rtis, SizeIs(rtcp::ExtendedReports::kMaxNumberOfDlrrItems)); for (size_t i = 0; i < rtcp::ExtendedReports::kMaxNumberOfDlrrItems; ++i) { @@ -969,17 +1105,21 @@ TEST_F(RtcpReceiverTest, StoresLastReceivedRrtrPerSsrc) { EXPECT_EQ(65536U * (kNumReports - i), last_xr_rtis[i].delay_since_last_rr); } - last_xr_rtis = rtcp_receiver_.ConsumeReceivedXrReferenceTimeInfo(); + last_xr_rtis = receiver.ConsumeReceivedXrReferenceTimeInfo(); ASSERT_THAT(last_xr_rtis, SizeIs(kNumBufferedReports)); } -TEST_F(RtcpReceiverTest, ReceiveReportTimeout) { +TEST(RtcpReceiverTest, ReceiveReportTimeout) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + const uint16_t kSequenceNumber = 1234; - system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs); + mocks.clock.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs); // No RR received, shouldn't trigger a timeout. - EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout()); - EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout()); + EXPECT_FALSE(receiver.RtcpRrTimeout()); + EXPECT_FALSE(receiver.RtcpRrSequenceNumberTimeout()); // Add a RR and advance the clock just enough to not trigger a timeout. rtcp::ReportBlock rb1; @@ -989,32 +1129,32 @@ TEST_F(RtcpReceiverTest, ReceiveReportTimeout) { rr1.SetSenderSsrc(kSenderSsrc); rr1.AddReportBlock(rb1); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); - EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); - InjectRtcpPacket(rr1); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport); + receiver.IncomingPacket(rr1.Build()); - system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs - 1); - EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout()); - EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout()); + mocks.clock.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs - 1); + EXPECT_FALSE(receiver.RtcpRrTimeout()); + EXPECT_FALSE(receiver.RtcpRrSequenceNumberTimeout()); // Add a RR with the same extended max as the previous RR to trigger a // sequence number timeout, but not a RR timeout. - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); - EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); - InjectRtcpPacket(rr1); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport); + receiver.IncomingPacket(rr1.Build()); - system_clock_.AdvanceTimeMilliseconds(2); - EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout()); - EXPECT_TRUE(rtcp_receiver_.RtcpRrSequenceNumberTimeout()); + mocks.clock.AdvanceTimeMilliseconds(2); + EXPECT_FALSE(receiver.RtcpRrTimeout()); + EXPECT_TRUE(receiver.RtcpRrSequenceNumberTimeout()); // Advance clock enough to trigger an RR timeout too. - system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs); - EXPECT_TRUE(rtcp_receiver_.RtcpRrTimeout()); + mocks.clock.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs); + EXPECT_TRUE(receiver.RtcpRrTimeout()); // We should only get one timeout even though we still haven't received a new // RR. - EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout()); - EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout()); + EXPECT_FALSE(receiver.RtcpRrTimeout()); + EXPECT_FALSE(receiver.RtcpRrSequenceNumberTimeout()); // Add a new RR with increase sequence number to reset timers. rtcp::ReportBlock rb2; @@ -1024,32 +1164,40 @@ TEST_F(RtcpReceiverTest, ReceiveReportTimeout) { rr2.SetSenderSsrc(kSenderSsrc); rr2.AddReportBlock(rb2); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); - EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); - InjectRtcpPacket(rr2); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport); + receiver.IncomingPacket(rr2.Build()); - EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout()); - EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout()); + EXPECT_FALSE(receiver.RtcpRrTimeout()); + EXPECT_FALSE(receiver.RtcpRrSequenceNumberTimeout()); // Verify we can get a timeout again once we've received new RR. - system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); - EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); - InjectRtcpPacket(rr2); + mocks.clock.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport); + receiver.IncomingPacket(rr2.Build()); - system_clock_.AdvanceTimeMilliseconds(kRtcpIntervalMs + 1); - EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout()); - EXPECT_TRUE(rtcp_receiver_.RtcpRrSequenceNumberTimeout()); + mocks.clock.AdvanceTimeMilliseconds(kRtcpIntervalMs + 1); + EXPECT_FALSE(receiver.RtcpRrTimeout()); + EXPECT_TRUE(receiver.RtcpRrSequenceNumberTimeout()); - system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs); - EXPECT_TRUE(rtcp_receiver_.RtcpRrTimeout()); + mocks.clock.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs); + EXPECT_TRUE(receiver.RtcpRrTimeout()); } -TEST_F(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) { - EXPECT_EQ(0u, rtcp_receiver_.TmmbrReceived().size()); +TEST(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + + EXPECT_THAT(receiver.TmmbrReceived(), IsEmpty()); } -TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) { +TEST(RtcpReceiverTest, TmmbrPacketAccepted) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + const uint32_t kBitrateBps = 30000; rtcp::Tmmbr tmmbr; tmmbr.SetSenderSsrc(kSenderSsrc); @@ -1060,19 +1208,24 @@ TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) { compound.Append(&sr); compound.Append(&tmmbr); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); - EXPECT_CALL(rtp_rtcp_impl_, SetTmmbn(SizeIs(1))); - EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); - EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps)); - InjectRtcpPacket(compound); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks); + EXPECT_CALL(mocks.rtp_rtcp_impl, SetTmmbn(SizeIs(1))); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport); + EXPECT_CALL(mocks.bandwidth_observer, + OnReceivedEstimatedBitrate(kBitrateBps)); + receiver.IncomingPacket(compound.Build()); - std::vector tmmbr_received = rtcp_receiver_.TmmbrReceived(); + std::vector tmmbr_received = receiver.TmmbrReceived(); ASSERT_EQ(1u, tmmbr_received.size()); EXPECT_EQ(kBitrateBps, tmmbr_received[0].bitrate_bps()); EXPECT_EQ(kSenderSsrc, tmmbr_received[0].ssrc()); } -TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) { +TEST(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + const uint32_t kBitrateBps = 30000; rtcp::Tmmbr tmmbr; tmmbr.SetSenderSsrc(kSenderSsrc); @@ -1084,15 +1237,19 @@ TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) { compound.Append(&sr); compound.Append(&tmmbr); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); - EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); - EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_)).Times(0); - InjectRtcpPacket(compound); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedEstimatedBitrate).Times(0); + receiver.IncomingPacket(compound.Build()); - EXPECT_EQ(0u, rtcp_receiver_.TmmbrReceived().size()); + EXPECT_EQ(0u, receiver.TmmbrReceived().size()); } -TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) { +TEST(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + rtcp::Tmmbr tmmbr; tmmbr.SetSenderSsrc(kSenderSsrc); tmmbr.AddTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, 0, 0)); @@ -1102,15 +1259,19 @@ TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) { compound.Append(&sr); compound.Append(&tmmbr); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); - EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); - EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_)).Times(0); - InjectRtcpPacket(compound); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedEstimatedBitrate).Times(0); + receiver.IncomingPacket(compound.Build()); - EXPECT_EQ(0u, rtcp_receiver_.TmmbrReceived().size()); + EXPECT_EQ(0u, receiver.TmmbrReceived().size()); } -TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) { +TEST(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + // Inject 3 packets "from" kSenderSsrc, kSenderSsrc+1, kSenderSsrc+2. // The times of arrival are starttime + 0, starttime + 5 and starttime + 10. for (uint32_t ssrc = kSenderSsrc; ssrc < kSenderSsrc + 3; ++ssrc) { @@ -1123,31 +1284,35 @@ TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) { compound.Append(&sr); compound.Append(&tmmbr); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); - EXPECT_CALL(rtp_rtcp_impl_, SetTmmbn(_)); - EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); - EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_)); - InjectRtcpPacket(compound); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks); + EXPECT_CALL(mocks.rtp_rtcp_impl, SetTmmbn); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedEstimatedBitrate); + receiver.IncomingPacket(compound.Build()); // 5 seconds between each packet. - system_clock_.AdvanceTimeMilliseconds(5000); + mocks.clock.AdvanceTimeMilliseconds(5000); } // It is now starttime + 15. - std::vector candidate_set = rtcp_receiver_.TmmbrReceived(); + std::vector candidate_set = receiver.TmmbrReceived(); ASSERT_EQ(3u, candidate_set.size()); EXPECT_EQ(30000U, candidate_set[0].bitrate_bps()); // We expect the timeout to be 25 seconds. Advance the clock by 12 // seconds, timing out the first packet. - system_clock_.AdvanceTimeMilliseconds(12000); - candidate_set = rtcp_receiver_.TmmbrReceived(); + mocks.clock.AdvanceTimeMilliseconds(12000); + candidate_set = receiver.TmmbrReceived(); ASSERT_EQ(2u, candidate_set.size()); EXPECT_EQ(kSenderSsrc + 1, candidate_set[0].ssrc()); } -TEST_F(RtcpReceiverTest, Callbacks) { +TEST(RtcpReceiverTest, Callbacks) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + MockRtcpCallbackImpl callback; - rtcp_receiver_.RegisterRtcpStatisticsCallback(&callback); + receiver.RegisterRtcpStatisticsCallback(&callback); const uint8_t kFractionLoss = 3; const uint32_t kCumulativeLoss = 7; @@ -1173,11 +1338,11 @@ TEST_F(RtcpReceiverTest, Callbacks) { kSequenceNumber), Field(&RtcpStatistics::jitter, kJitter)), kReceiverMainSsrc)); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); - EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); - InjectRtcpPacket(rr1); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport); + receiver.IncomingPacket(rr1.Build()); - rtcp_receiver_.RegisterRtcpStatisticsCallback(nullptr); + receiver.RegisterRtcpStatisticsCallback(nullptr); // Add arbitrary numbers, callback should not be called. rtcp::ReportBlock rb2; @@ -1191,16 +1356,20 @@ TEST_F(RtcpReceiverTest, Callbacks) { rr2.SetSenderSsrc(kSenderSsrc); rr2.AddReportBlock(rb2); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); - EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); - EXPECT_CALL(callback, StatisticsUpdated(_, _)).Times(0); - InjectRtcpPacket(rr2); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport); + EXPECT_CALL(callback, StatisticsUpdated).Times(0); + receiver.IncomingPacket(rr2.Build()); } -TEST_F(RtcpReceiverTest, - VerifyBlockAndTimestampObtainedFromReportBlockDataObserver) { +TEST(RtcpReceiverTest, + VerifyBlockAndTimestampObtainedFromReportBlockDataObserver) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + MockReportBlockDataObserverImpl observer; - rtcp_receiver_.SetReportBlockDataObserver(&observer); + receiver.SetReportBlockDataObserver(&observer); const uint8_t kFractionLoss = 3; const uint32_t kCumulativeLoss = 7; @@ -1209,7 +1378,7 @@ TEST_F(RtcpReceiverTest, const int64_t kUtcNowUs = 42; // The "report_block_timestamp_utc_us" is obtained from the global UTC clock - // (not the simulcated |system_clock_|) and requires a scoped fake clock. + // (not the simulcated |mocks.clock|) and requires a scoped fake clock. rtc::ScopedFakeClock fake_clock; fake_clock.SetTime(Timestamp::Micros(kUtcNowUs)); @@ -1238,22 +1407,26 @@ TEST_F(RtcpReceiverTest, // No RTT is calculated in this test. EXPECT_EQ(0u, report_block_data.num_rtts()); }); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks); - EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport); - InjectRtcpPacket(rtcp_report); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport); + receiver.IncomingPacket(rtcp_report.Build()); } -TEST_F(RtcpReceiverTest, VerifyRttObtainedFromReportBlockDataObserver) { +TEST(RtcpReceiverTest, VerifyRttObtainedFromReportBlockDataObserver) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + MockReportBlockDataObserverImpl observer; - rtcp_receiver_.SetReportBlockDataObserver(&observer); + receiver.SetReportBlockDataObserver(&observer); const int64_t kRttMs = 120; const uint32_t kDelayNtp = 123000; const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp); uint32_t sent_ntp = - CompactNtp(TimeMicrosToNtp(system_clock_.TimeInMicroseconds())); - system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); + CompactNtp(TimeMicrosToNtp(mocks.clock.TimeInMicroseconds())); + mocks.clock.AdvanceTimeMilliseconds(kRttMs + kDelayMs); rtcp::SenderReport sr; sr.SetSenderSsrc(kSenderSsrc); @@ -1266,8 +1439,8 @@ TEST_F(RtcpReceiverTest, VerifyRttObtainedFromReportBlockDataObserver) { block.SetLastSr(0); sr.AddReportBlock(block); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks); - EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport); InSequence sequence; EXPECT_CALL(observer, OnReportBlockDataUpdated) .WillOnce([&](ReportBlockData report_block_data) { @@ -1285,10 +1458,14 @@ TEST_F(RtcpReceiverTest, VerifyRttObtainedFromReportBlockDataObserver) { report_block_data.report_block().source_ssrc); EXPECT_EQ(0u, report_block_data.num_rtts()); }); - InjectRtcpPacket(sr); + receiver.IncomingPacket(sr.Build()); } -TEST_F(RtcpReceiverTest, GetReportBlockDataAfterOneReportBlock) { +TEST(RtcpReceiverTest, GetReportBlockDataAfterOneReportBlock) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + const uint16_t kSequenceNumber = 1234; rtcp::ReportBlock rtcp_block; @@ -1298,11 +1475,11 @@ TEST_F(RtcpReceiverTest, GetReportBlockDataAfterOneReportBlock) { rtcp::ReceiverReport rtcp_report; rtcp_report.SetSenderSsrc(kSenderSsrc); rtcp_report.AddReportBlock(rtcp_block); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks); - EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport); - InjectRtcpPacket(rtcp_report); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport); + receiver.IncomingPacket(rtcp_report.Build()); - auto report_block_datas = rtcp_receiver_.GetLatestReportBlockData(); + auto report_block_datas = receiver.GetLatestReportBlockData(); ASSERT_THAT(report_block_datas, SizeIs(1)); EXPECT_EQ(kReceiverMainSsrc, report_block_datas[0].report_block().source_ssrc); @@ -1311,7 +1488,11 @@ TEST_F(RtcpReceiverTest, GetReportBlockDataAfterOneReportBlock) { report_block_datas[0].report_block().extended_highest_sequence_number); } -TEST_F(RtcpReceiverTest, GetReportBlockDataAfterTwoReportBlocksOfSameSsrc) { +TEST(RtcpReceiverTest, GetReportBlockDataAfterTwoReportBlocksOfSameSsrc) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + const uint16_t kSequenceNumber1 = 1234; const uint16_t kSequenceNumber2 = 1235; @@ -1322,9 +1503,9 @@ TEST_F(RtcpReceiverTest, GetReportBlockDataAfterTwoReportBlocksOfSameSsrc) { rtcp::ReceiverReport rtcp_report1; rtcp_report1.SetSenderSsrc(kSenderSsrc); rtcp_report1.AddReportBlock(rtcp_block1); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks); - EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport); - InjectRtcpPacket(rtcp_report1); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport); + receiver.IncomingPacket(rtcp_report1.Build()); // Inject a report block with an increased the sequence number for the same // source SSRC. @@ -1335,12 +1516,12 @@ TEST_F(RtcpReceiverTest, GetReportBlockDataAfterTwoReportBlocksOfSameSsrc) { rtcp::ReceiverReport rtcp_report2; rtcp_report2.SetSenderSsrc(kSenderSsrc); rtcp_report2.AddReportBlock(rtcp_block2); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks); - EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport); - InjectRtcpPacket(rtcp_report2); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport); + receiver.IncomingPacket(rtcp_report2.Build()); // Only the latest block should be returned. - auto report_block_datas = rtcp_receiver_.GetLatestReportBlockData(); + auto report_block_datas = receiver.GetLatestReportBlockData(); ASSERT_THAT(report_block_datas, SizeIs(1)); EXPECT_EQ(kReceiverMainSsrc, report_block_datas[0].report_block().source_ssrc); @@ -1349,8 +1530,11 @@ TEST_F(RtcpReceiverTest, GetReportBlockDataAfterTwoReportBlocksOfSameSsrc) { report_block_datas[0].report_block().extended_highest_sequence_number); } -TEST_F(RtcpReceiverTest, - GetReportBlockDataAfterTwoReportBlocksOfDifferentSsrcs) { +TEST(RtcpReceiverTest, GetReportBlockDataAfterTwoReportBlocksOfDifferentSsrcs) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + const uint16_t kSequenceNumber1 = 1234; const uint16_t kSequenceNumber2 = 42; @@ -1361,9 +1545,9 @@ TEST_F(RtcpReceiverTest, rtcp::ReceiverReport rtcp_report1; rtcp_report1.SetSenderSsrc(kSenderSsrc); rtcp_report1.AddReportBlock(rtcp_block1); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks); - EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport); - InjectRtcpPacket(rtcp_report1); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport); + receiver.IncomingPacket(rtcp_report1.Build()); // Inject a report block for a different source SSRC. rtcp::ReportBlock rtcp_block2; @@ -1373,12 +1557,12 @@ TEST_F(RtcpReceiverTest, rtcp::ReceiverReport rtcp_report2; rtcp_report2.SetSenderSsrc(kSenderSsrc); rtcp_report2.AddReportBlock(rtcp_block2); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks); - EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport); - InjectRtcpPacket(rtcp_report2); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnReceivedRtcpReportBlocks); + EXPECT_CALL(mocks.bandwidth_observer, OnReceivedRtcpReceiverReport); + receiver.IncomingPacket(rtcp_report2.Build()); // Both report blocks should be returned. - auto report_block_datas = rtcp_receiver_.GetLatestReportBlockData(); + auto report_block_datas = receiver.GetLatestReportBlockData(); ASSERT_THAT(report_block_datas, SizeIs(2)); EXPECT_EQ(kReceiverMainSsrc, report_block_datas[0].report_block().source_ssrc); @@ -1392,7 +1576,11 @@ TEST_F(RtcpReceiverTest, report_block_datas[1].report_block().extended_highest_sequence_number); } -TEST_F(RtcpReceiverTest, ReceivesTransportFeedback) { +TEST(RtcpReceiverTest, ReceivesTransportFeedback) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + rtcp::TransportFeedback packet; packet.SetMediaSsrc(kReceiverMainSsrc); packet.SetSenderSsrc(kSenderSsrc); @@ -1400,24 +1588,33 @@ TEST_F(RtcpReceiverTest, ReceivesTransportFeedback) { packet.AddReceivedPacket(1, 1000); EXPECT_CALL( - transport_feedback_observer_, + mocks.transport_feedback_observer, OnTransportFeedback(AllOf( Property(&rtcp::TransportFeedback::media_ssrc, kReceiverMainSsrc), Property(&rtcp::TransportFeedback::sender_ssrc, kSenderSsrc)))); - InjectRtcpPacket(packet); + receiver.IncomingPacket(packet.Build()); } -TEST_F(RtcpReceiverTest, ReceivesRemb) { +TEST(RtcpReceiverTest, ReceivesRemb) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + const uint32_t kBitrateBps = 500000; rtcp::Remb remb; remb.SetSenderSsrc(kSenderSsrc); remb.SetBitrateBps(kBitrateBps); - EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps)); - InjectRtcpPacket(remb); + EXPECT_CALL(mocks.bandwidth_observer, + OnReceivedEstimatedBitrate(kBitrateBps)); + receiver.IncomingPacket(remb.Build()); } -TEST_F(RtcpReceiverTest, HandlesInvalidTransportFeedback) { +TEST(RtcpReceiverTest, HandlesInvalidTransportFeedback) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + // Send a compound packet with a TransportFeedback followed by something else. rtcp::TransportFeedback packet; packet.SetMediaSsrc(kReceiverMainSsrc); @@ -1440,13 +1637,18 @@ TEST_F(RtcpReceiverTest, HandlesInvalidTransportFeedback) { 42); // Stress no transport feedback is expected. - EXPECT_CALL(transport_feedback_observer_, OnTransportFeedback(_)).Times(0); + EXPECT_CALL(mocks.transport_feedback_observer, OnTransportFeedback).Times(0); // But remb should be processed and cause a callback - EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps)); - InjectRtcpPacket(built_packet); + EXPECT_CALL(mocks.bandwidth_observer, + OnReceivedEstimatedBitrate(kBitrateBps)); + receiver.IncomingPacket(built_packet); } -TEST_F(RtcpReceiverTest, Nack) { +TEST(RtcpReceiverTest, Nack) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + const uint16_t kNackList1[] = {1, 2, 3, 5}; const uint16_t kNackList23[] = {5, 7, 30, 40, 41, 58, 59, 61, 63}; const size_t kNackListLength2 = 4; @@ -1460,15 +1662,16 @@ TEST_F(RtcpReceiverTest, Nack) { nack1.SetMediaSsrc(kReceiverMainSsrc); nack1.SetPacketIds(kNackList1, arraysize(kNackList1)); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedNack(ElementsAreArray(kNackList1))); - EXPECT_CALL(packet_type_counter_observer_, + EXPECT_CALL(mocks.rtp_rtcp_impl, + OnReceivedNack(ElementsAreArray(kNackList1))); + EXPECT_CALL(mocks.packet_type_counter_observer, RtcpPacketTypesCounterUpdated( kReceiverMainSsrc, AllOf(Field(&RtcpPacketTypeCounter::nack_requests, arraysize(kNackList1)), Field(&RtcpPacketTypeCounter::unique_nack_requests, arraysize(kNackList1))))); - InjectRtcpPacket(nack1); + receiver.IncomingPacket(nack1.Build()); rtcp::Nack nack2; nack2.SetSenderSsrc(kSenderSsrc); @@ -1484,18 +1687,23 @@ TEST_F(RtcpReceiverTest, Nack) { two_nacks.Append(&nack2); two_nacks.Append(&nack3); - EXPECT_CALL(rtp_rtcp_impl_, OnReceivedNack(ElementsAreArray(kNackList23))); - EXPECT_CALL(packet_type_counter_observer_, + EXPECT_CALL(mocks.rtp_rtcp_impl, + OnReceivedNack(ElementsAreArray(kNackList23))); + EXPECT_CALL(mocks.packet_type_counter_observer, RtcpPacketTypesCounterUpdated( kReceiverMainSsrc, AllOf(Field(&RtcpPacketTypeCounter::nack_requests, arraysize(kNackList1) + arraysize(kNackList23)), Field(&RtcpPacketTypeCounter::unique_nack_requests, nack_set.size())))); - InjectRtcpPacket(two_nacks); + receiver.IncomingPacket(two_nacks.Build()); } -TEST_F(RtcpReceiverTest, NackNotForUsIgnored) { +TEST(RtcpReceiverTest, NackNotForUsIgnored) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + const uint16_t kNackList1[] = {1, 2, 3, 5}; const size_t kNackListLength1 = std::end(kNackList1) - std::begin(kNackList1); @@ -1504,22 +1712,30 @@ TEST_F(RtcpReceiverTest, NackNotForUsIgnored) { nack.SetMediaSsrc(kNotToUsSsrc); nack.SetPacketIds(kNackList1, kNackListLength1); - EXPECT_CALL(packet_type_counter_observer_, + EXPECT_CALL(mocks.packet_type_counter_observer, RtcpPacketTypesCounterUpdated( _, Field(&RtcpPacketTypeCounter::nack_requests, 0))); - InjectRtcpPacket(nack); + receiver.IncomingPacket(nack.Build()); } -TEST_F(RtcpReceiverTest, ForceSenderReport) { +TEST(RtcpReceiverTest, ForceSenderReport) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + rtcp::RapidResyncRequest rr; rr.SetSenderSsrc(kSenderSsrc); rr.SetMediaSsrc(kReceiverMainSsrc); - EXPECT_CALL(rtp_rtcp_impl_, OnRequestSendReport()); - InjectRtcpPacket(rr); + EXPECT_CALL(mocks.rtp_rtcp_impl, OnRequestSendReport()); + receiver.IncomingPacket(rr.Build()); } -TEST_F(RtcpReceiverTest, ReceivesTargetBitrate) { +TEST(RtcpReceiverTest, ReceivesTargetBitrate) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + VideoBitrateAllocation expected_allocation; expected_allocation.SetBitrate(0, 0, 10000); expected_allocation.SetBitrate(0, 1, 20000); @@ -1537,19 +1753,23 @@ TEST_F(RtcpReceiverTest, ReceivesTargetBitrate) { // Wrong sender ssrc, target bitrate should be discarded. xr.SetSenderSsrc(kSenderSsrc + 1); - EXPECT_CALL(bitrate_allocation_observer_, + EXPECT_CALL(mocks.bitrate_allocation_observer, OnBitrateAllocationUpdated(expected_allocation)) .Times(0); - InjectRtcpPacket(xr); + receiver.IncomingPacket(xr.Build()); // Set correct ssrc, callback should be called once. xr.SetSenderSsrc(kSenderSsrc); - EXPECT_CALL(bitrate_allocation_observer_, + EXPECT_CALL(mocks.bitrate_allocation_observer, OnBitrateAllocationUpdated(expected_allocation)); - InjectRtcpPacket(xr); + receiver.IncomingPacket(xr.Build()); } -TEST_F(RtcpReceiverTest, HandlesIncorrectTargetBitrate) { +TEST(RtcpReceiverTest, HandlesIncorrectTargetBitrate) { + ReceiverMocks mocks; + RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); + receiver.SetRemoteSSRC(kSenderSsrc); + VideoBitrateAllocation expected_allocation; expected_allocation.SetBitrate(0, 0, 10000); @@ -1562,9 +1782,9 @@ TEST_F(RtcpReceiverTest, HandlesIncorrectTargetBitrate) { xr.SetTargetBitrate(bitrate); xr.SetSenderSsrc(kSenderSsrc); - EXPECT_CALL(bitrate_allocation_observer_, + EXPECT_CALL(mocks.bitrate_allocation_observer, OnBitrateAllocationUpdated(expected_allocation)); - InjectRtcpPacket(xr); + receiver.IncomingPacket(xr.Build()); } } // namespace webrtc