Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(79)

Side by Side Diff: webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc

Issue 1527003002: [rtp_rtcp] RtcpReceiverTest rewritten using public available interface (observers) instead intermid… (Closed) Base URL: https://chromium.googlesource.com/external/webrtc.git@master
Patch Set: rebase Created 4 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 /* 1 /*
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 * 3 *
4 * Use of this source code is governed by a BSD-style license 4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source 5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found 6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may 7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree. 8 * be found in the AUTHORS file in the root of the source tree.
9 */ 9 */
10 10
11 11
12 /* 12 /*
13 * This file includes unit tests for the RTCPReceiver. 13 * This file includes unit tests for the RTCPReceiver.
14 */ 14 */
15 #include "testing/gmock/include/gmock/gmock.h" 15 #include "testing/gmock/include/gmock/gmock.h"
16 #include "testing/gtest/include/gtest/gtest.h" 16 #include "testing/gtest/include/gtest/gtest.h"
17 17
18 #include "webrtc/common_types.h" 18 #include "webrtc/common_types.h"
19 #include "webrtc/modules/remote_bitrate_estimator/include/mock/mock_remote_bitra te_observer.h" 19 #include "webrtc/modules/remote_bitrate_estimator/include/mock/mock_remote_bitra te_estimator.h"
20 #include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_singl e_stream.h" 20 #include "webrtc/modules/rtp_rtcp/mocks/mock_rtcp_observers.h"
21 #include "webrtc/modules/rtp_rtcp/source/byte_io.h" 21 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
22 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h" 22 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
23 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h" 23 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h"
24 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h" 24 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h"
25 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h" 25 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h"
26 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h" 26 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
27 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.h" 27 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.h"
28 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h"
28 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.h" 29 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.h"
29 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h" 30 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
30 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h" 31 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h"
32 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi.h"
31 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h" 33 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h"
32 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h" 34 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
33 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sli.h" 35 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sli.h"
34 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h" 36 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h"
35 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" 37 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
36 #include "webrtc/modules/rtp_rtcp/source/rtcp_receiver.h" 38 #include "webrtc/modules/rtp_rtcp/source/rtcp_receiver.h"
37 #include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h"
38 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h" 39 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h"
39 #include "webrtc/modules/rtp_rtcp/source/time_util.h" 40 #include "webrtc/modules/rtp_rtcp/source/time_util.h"
40 #include "webrtc/system_wrappers/include/ntp_time.h" 41 #include "webrtc/system_wrappers/include/ntp_time.h"
42 #include "webrtc/test/mock_transport.h"
43
44 using testing::_;
45 using testing::AllOf;
46 using testing::Field;
47 using testing::IsEmpty;
48 using testing::NiceMock;
49 using testing::Property;
50 using testing::SizeIs;
51 using testing::StrEq;
52 using testing::StrictMock;
53 using testing::UnorderedElementsAre;
41 54
42 namespace webrtc { 55 namespace webrtc {
43 56
44 namespace { // Anonymous namespace; hide utility functions and classes.
45
46 // This test transport verifies that no functions get called.
47 class TestTransport : public Transport,
48 public NullRtpData {
49 public:
50 explicit TestTransport() : rtcp_receiver_(nullptr) {}
51 void SetRTCPReceiver(RTCPReceiver* rtcp_receiver) {
52 rtcp_receiver_ = rtcp_receiver;
53 }
54 bool SendRtp(const uint8_t* /*data*/,
55 size_t /*len*/,
56 const PacketOptions& options) override {
57 ADD_FAILURE(); // FAIL() gives a compile error.
58 return false;
59 }
60
61 bool SendRtcp(const uint8_t* packet, size_t packet_len) override {
62 ADD_FAILURE();
63 return true;
64 }
65
66 int OnReceivedPayloadData(const uint8_t* payloadData,
67 const size_t payloadSize,
68 const WebRtcRTPHeader* rtpHeader) override {
69 ADD_FAILURE();
70 return 0;
71 }
72 RTCPReceiver* rtcp_receiver_;
73 };
74
75 class RtcpReceiverTest : public ::testing::Test { 57 class RtcpReceiverTest : public ::testing::Test {
76 protected: 58 protected:
77 RtcpReceiverTest() 59 RtcpReceiverTest() : system_clock_(1335900000) {
78 : over_use_detector_options_(),
79 system_clock_(1335900000),
80 remote_bitrate_observer_(),
81 remote_bitrate_estimator_(
82 new RemoteBitrateEstimatorSingleStream(&remote_bitrate_observer_,
83 &system_clock_)) {
84 test_transport_ = new TestTransport();
85
86 RtpRtcp::Configuration configuration; 60 RtpRtcp::Configuration configuration;
87 configuration.audio = false; 61 configuration.audio = false;
88 configuration.clock = &system_clock_; 62 configuration.clock = &system_clock_;
89 configuration.outgoing_transport = test_transport_; 63 configuration.outgoing_transport = &transport_;
90 configuration.remote_bitrate_estimator = remote_bitrate_estimator_.get(); 64 configuration.remote_bitrate_estimator = &remote_bitrate_estimator_;
91 rtp_rtcp_impl_ = new ModuleRtpRtcpImpl(configuration); 65 rtp_rtcp_impl_.reset(new ModuleRtpRtcpImpl(configuration));
92 rtcp_receiver_ = new RTCPReceiver(&system_clock_, false, nullptr, nullptr, 66 rtcp_receiver_.reset(
93 nullptr, nullptr, rtp_rtcp_impl_); 67 new RTCPReceiver(&system_clock_, false, &packet_type_counter_observer_,
94 test_transport_->SetRTCPReceiver(rtcp_receiver_); 68 &bandwidth_observer_, &intra_frame_observer_,
95 } 69 &transport_feedback_observer_, rtp_rtcp_impl_.get()));
96 ~RtcpReceiverTest() {
97 delete rtcp_receiver_;
98 delete rtp_rtcp_impl_;
99 delete test_transport_;
100 } 70 }
101 71
102 // Injects an RTCP packet into the receiver. 72 void InjectPacket(const rtcp::RtcpPacket& packet) {
103 // Returns 0 for OK, non-0 for failure. 73 rtc::Buffer raw = packet.Build();
104 int InjectRtcpPacket(const uint8_t* packet, 74 EXPECT_TRUE(rtcp_receiver_->IncomingPacket(raw.data(), raw.size()));
105 uint16_t packet_len) {
106 RTCPUtility::RTCPParserV2 rtcpParser(packet,
107 packet_len,
108 true); // Allow non-compound RTCP
109
110 RTCPHelp::RTCPPacketInformation rtcpPacketInformation;
111 EXPECT_EQ(0, rtcp_receiver_->IncomingRTCPPacket(rtcpPacketInformation,
112 &rtcpParser));
113 rtcp_receiver_->TriggerCallbacksFromRTCPPacket(rtcpPacketInformation);
114 // The NACK list is on purpose not copied below as it isn't needed by the
115 // test.
116 rtcp_packet_info_.rtcpPacketTypeFlags =
117 rtcpPacketInformation.rtcpPacketTypeFlags;
118 rtcp_packet_info_.remoteSSRC = rtcpPacketInformation.remoteSSRC;
119 rtcp_packet_info_.applicationSubType =
120 rtcpPacketInformation.applicationSubType;
121 rtcp_packet_info_.applicationName = rtcpPacketInformation.applicationName;
122 rtcp_packet_info_.applicationLength =
123 rtcpPacketInformation.applicationLength;
124 rtcp_packet_info_.report_blocks = rtcpPacketInformation.report_blocks;
125 rtcp_packet_info_.rtt = rtcpPacketInformation.rtt;
126 rtcp_packet_info_.interArrivalJitter =
127 rtcpPacketInformation.interArrivalJitter;
128 rtcp_packet_info_.sliPictureId = rtcpPacketInformation.sliPictureId;
129 rtcp_packet_info_.rpsiPictureId = rtcpPacketInformation.rpsiPictureId;
130 rtcp_packet_info_.receiverEstimatedMaxBitrate =
131 rtcpPacketInformation.receiverEstimatedMaxBitrate;
132 rtcp_packet_info_.ntp_secs = rtcpPacketInformation.ntp_secs;
133 rtcp_packet_info_.ntp_frac = rtcpPacketInformation.ntp_frac;
134 rtcp_packet_info_.rtp_timestamp = rtcpPacketInformation.rtp_timestamp;
135 rtcp_packet_info_.xr_dlrr_item = rtcpPacketInformation.xr_dlrr_item;
136 if (rtcpPacketInformation.VoIPMetric)
137 rtcp_packet_info_.AddVoIPMetric(rtcpPacketInformation.VoIPMetric);
138 rtcp_packet_info_.transport_feedback_.reset(
139 rtcpPacketInformation.transport_feedback_.release());
140 return 0;
141 } 75 }
142 76
143 OverUseDetectorOptions over_use_detector_options_; 77 void SetSsrc(uint32_t ssrc) {
78 std::set<uint32_t> ssrcs;
79 ssrcs.insert(ssrc);
80 EXPECT_CALL(intra_frame_observer_, OnLocalSsrcChanged(0, ssrc));
81 rtcp_receiver_->SetSsrcs(ssrc, ssrcs);
82 }
83
84 template <typename Container>
85 void SetSsrcs(const Container& c) {
86 std::set<uint32_t> ssrcs(std::begin(c), std::end(c));
87 ASSERT_FALSE(ssrcs.empty());
88 uint32_t main_ssrc = *std::begin(c);
89 EXPECT_CALL(intra_frame_observer_, OnLocalSsrcChanged(0, main_ssrc));
90 rtcp_receiver_->SetSsrcs(main_ssrc, ssrcs);
91 }
92
144 SimulatedClock system_clock_; 93 SimulatedClock system_clock_;
145 ModuleRtpRtcpImpl* rtp_rtcp_impl_; 94
146 RTCPReceiver* rtcp_receiver_; 95 StrictMock<MockTransport> transport_;
147 TestTransport* test_transport_; 96 StrictMock<MockRemoteBitrateEstimator> remote_bitrate_estimator_;
148 RTCPHelp::RTCPPacketInformation rtcp_packet_info_; 97 rtc::scoped_ptr<ModuleRtpRtcpImpl> rtp_rtcp_impl_;
149 MockRemoteBitrateObserver remote_bitrate_observer_; 98
150 rtc::scoped_ptr<RemoteBitrateEstimator> remote_bitrate_estimator_; 99 // Callbacks to packet_type_counter_observer are frequent but most of the time
100 // are not interesting.
101 NiceMock<MockRtcpPacketTypeCounterObserver> packet_type_counter_observer_;
102 StrictMock<MockRtcpBandwidthObserver> bandwidth_observer_;
103 StrictMock<MockRtcpIntraFrameObserver> intra_frame_observer_;
104 StrictMock<MockTransportFeedbackObserver> transport_feedback_observer_;
105 rtc::scoped_ptr<RTCPReceiver> rtcp_receiver_;
151 }; 106 };
152 107
153
154 TEST_F(RtcpReceiverTest, BrokenPacketIsIgnored) { 108 TEST_F(RtcpReceiverTest, BrokenPacketIsIgnored) {
155 const uint8_t bad_packet[] = {0, 0, 0, 0}; 109 const uint8_t bad_packet[] = {0, 0, 0, 0};
156 EXPECT_EQ(0, InjectRtcpPacket(bad_packet, sizeof(bad_packet))); 110 int64_t now = system_clock_.TimeInMilliseconds();
157 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 111 EXPECT_CALL(packet_type_counter_observer_,
112 RtcpPacketTypesCounterUpdated(_, _))
113 .Times(0);
114 EXPECT_FALSE(rtcp_receiver_->IncomingPacket(bad_packet, sizeof(bad_packet)));
115 EXPECT_NE(now, rtcp_receiver_->LastReceived());
158 } 116 }
159 117
160 TEST_F(RtcpReceiverTest, InjectSrPacket) { 118 TEST_F(RtcpReceiverTest, InjectSrPacket) {
161 const uint32_t kSenderSsrc = 0x10203; 119 const uint32_t kSenderSsrc = 0x10203;
120 int64_t now = system_clock_.TimeInMilliseconds();
162 rtcp::SenderReport sr; 121 rtcp::SenderReport sr;
163 sr.From(kSenderSsrc); 122 sr.From(kSenderSsrc);
164 rtc::Buffer packet = sr.Build(); 123 EXPECT_CALL(bandwidth_observer_,
165 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 124 OnReceivedRtcpReceiverReport(IsEmpty(), _, now));
125 InjectPacket(sr);
126 // The packet should be processed.
127 EXPECT_EQ(now, rtcp_receiver_->LastReceived());
166 // The parser will note the remote SSRC on a SR from other than his 128 // The parser will note the remote SSRC on a SR from other than his
167 // expected peer, but will not flag that he's gotten a packet. 129 // expected peer, but will not flag that he's gotten a packet.
168 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); 130 RTCPSenderInfo info;
169 EXPECT_EQ(0U, kRtcpSr & rtcp_packet_info_.rtcpPacketTypeFlags); 131 EXPECT_EQ(-1, rtcp_receiver_->SenderInfoReceived(&info));
170 } 132 }
171 133
172 TEST_F(RtcpReceiverTest, InjectSrPacketFromExpectedPeer) { 134 TEST_F(RtcpReceiverTest, InjectSrPacketFromExpectedPeer) {
173 const uint32_t kSenderSsrc = 0x10203; 135 const uint32_t kSenderSsrc = 0x10203;
136 int64_t now = system_clock_.TimeInMilliseconds();
137
138 RTCPSenderInfo info;
174 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); 139 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc);
175 rtcp::SenderReport sr; 140 rtcp::SenderReport sr;
176 sr.From(kSenderSsrc); 141 sr.From(kSenderSsrc);
177 rtc::Buffer packet = sr.Build(); 142
178 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 143 EXPECT_EQ(-1, rtcp_receiver_->SenderInfoReceived(&info));
179 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); 144 EXPECT_CALL(bandwidth_observer_,
180 EXPECT_EQ(kRtcpSr, rtcp_packet_info_.rtcpPacketTypeFlags); 145 OnReceivedRtcpReceiverReport(IsEmpty(), _, now));
146 InjectPacket(sr);
147 EXPECT_EQ(now, rtcp_receiver_->LastReceived());
148 EXPECT_EQ(0, rtcp_receiver_->SenderInfoReceived(&info));
181 } 149 }
182 150
183 TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesRTT) { 151 TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesRTT) {
184 Random r(0x0123456789abcdef); 152 Random r(0x0123456789abcdef);
185 const uint32_t kSenderSsrc = r.Rand(0x00000001u, 0xfffffffeu); 153 const uint32_t kSenderSsrc = r.Rand(0x00000001u, 0xfffffffeu);
186 const uint32_t kRemoteSsrc = r.Rand(0x00000001u, 0xfffffffeu); 154 const uint32_t kRemoteSsrc = r.Rand(0x00000001u, 0xfffffffeu);
187 const int64_t kRttMs = r.Rand(1, 18 * 3600 * 1000); 155 const int64_t kRttMs = r.Rand(1, 18 * 3600 * 1000);
188 const uint32_t kDelayNtp = r.Rand<uint32_t>(); 156 const uint32_t kDelayNtp = r.Rand<uint32_t>();
189 const uint32_t kDelayMs = CompactNtpIntervalToMs(kDelayNtp); 157 const uint32_t kDelayMs = CompactNtpIntervalToMs(kDelayNtp);
190 158
191 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); 159 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc);
192 std::set<uint32_t> ssrcs; 160 SetSsrc(kRemoteSsrc);
193 ssrcs.insert(kRemoteSsrc);
194 rtcp_receiver_->SetSsrcs(kRemoteSsrc, ssrcs);
195 161
196 int64_t rtt_ms = 0; 162 int64_t rtt_ms = 0;
197 EXPECT_EQ( 163 EXPECT_EQ(
198 -1, rtcp_receiver_->RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); 164 -1, rtcp_receiver_->RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr));
199 165
200 uint32_t sent_ntp = CompactNtp(NtpTime(system_clock_)); 166 uint32_t sent_ntp = CompactNtp(NtpTime(system_clock_));
201 system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); 167 system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
202 168
203 rtcp::SenderReport sr; 169 rtcp::SenderReport sr;
204 sr.From(kSenderSsrc); 170 sr.From(kSenderSsrc);
205 rtcp::ReportBlock block; 171 rtcp::ReportBlock block;
206 block.To(kRemoteSsrc); 172 block.To(kRemoteSsrc);
207 block.WithLastSr(sent_ntp); 173 block.WithLastSr(sent_ntp);
208 block.WithDelayLastSr(kDelayNtp); 174 block.WithDelayLastSr(kDelayNtp);
209 sr.WithReportBlock(block); 175 sr.WithReportBlock(block);
210 176
211 rtc::Buffer packet = sr.Build(); 177 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
212 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 178 InjectPacket(sr);
213 179
214 EXPECT_EQ( 180 EXPECT_EQ(
215 0, rtcp_receiver_->RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); 181 0, rtcp_receiver_->RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr));
216 EXPECT_NEAR(kRttMs, rtt_ms, 1); 182 EXPECT_NEAR(kRttMs, rtt_ms, 1);
217 } 183 }
218 184
219 TEST_F(RtcpReceiverTest, InjectRrPacket) { 185 TEST_F(RtcpReceiverTest, InjectRrPacket) {
220 const uint32_t kSenderSsrc = 0x10203; 186 const uint32_t kSenderSsrc = 0x10203;
187 int64_t now = system_clock_.TimeInMilliseconds();
188
221 rtcp::ReceiverReport rr; 189 rtcp::ReceiverReport rr;
222 rr.From(kSenderSsrc); 190 rr.From(kSenderSsrc);
223 rtc::Buffer packet = rr.Build(); 191 EXPECT_CALL(bandwidth_observer_,
224 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 192 OnReceivedRtcpReceiverReport(IsEmpty(), _, now));
225 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); 193 InjectPacket(rr);
226 EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags); 194 EXPECT_EQ(now, rtcp_receiver_->LastReceived());
227 ASSERT_EQ(0u, rtcp_packet_info_.report_blocks.size()); 195 RTCPSenderInfo info;
196 EXPECT_EQ(-1, rtcp_receiver_->SenderInfoReceived(&info));
197 EXPECT_EQ(now, rtcp_receiver_->LastReceivedReceiverReport());
198 std::vector<RTCPReportBlock> report_blocks;
199 rtcp_receiver_->StatisticsReceived(&report_blocks);
200 EXPECT_TRUE(report_blocks.empty());
228 } 201 }
229 202
230 TEST_F(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) { 203 TEST_F(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) {
231 const uint32_t kSenderSsrc = 0x10203; 204 const uint32_t kSenderSsrc = 0x10203;
232 const uint32_t kSourceSsrc = 0x123456; 205 const uint32_t kSourceSsrc = 0x123456;
233 std::set<uint32_t> ssrcs; 206 int64_t now = system_clock_.TimeInMilliseconds();
234 ssrcs.insert(kSourceSsrc); 207 SetSsrc(kSourceSsrc);
235 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
236
237 rtcp::ReportBlock rb; 208 rtcp::ReportBlock rb;
238 rb.To(kSourceSsrc + 1); 209 rb.To(kSourceSsrc + 1);
239 rtcp::ReceiverReport rr; 210 rtcp::ReceiverReport rr;
240 rr.From(kSenderSsrc); 211 rr.From(kSenderSsrc);
241 rr.WithReportBlock(rb); 212 rr.WithReportBlock(rb);
242 rtc::Buffer packet = rr.Build(); 213 EXPECT_CALL(bandwidth_observer_,
243 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 214 OnReceivedRtcpReceiverReport(IsEmpty(), _, now));
244 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); 215 InjectPacket(rr);
245 EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags); 216 EXPECT_EQ(now, rtcp_receiver_->LastReceivedReceiverReport());
246 ASSERT_EQ(0u, rtcp_packet_info_.report_blocks.size());
247 217
248 std::vector<RTCPReportBlock> received_blocks; 218 std::vector<RTCPReportBlock> received_blocks;
249 rtcp_receiver_->StatisticsReceived(&received_blocks); 219 rtcp_receiver_->StatisticsReceived(&received_blocks);
250 EXPECT_TRUE(received_blocks.empty()); 220 EXPECT_TRUE(received_blocks.empty());
251 } 221 }
252 222
253 TEST_F(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) { 223 TEST_F(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) {
254 const uint32_t kSenderSsrc = 0x10203; 224 const uint32_t kSenderSsrc = 0x10203;
255 const uint32_t kSourceSsrc = 0x123456; 225 const uint32_t kSourceSsrc = 0x123456;
256 std::set<uint32_t> ssrcs; 226 int64_t now = system_clock_.TimeInMilliseconds();
257 ssrcs.insert(kSourceSsrc); 227 SetSsrc(kSourceSsrc);
258 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
259 228
260 rtcp::ReportBlock rb; 229 rtcp::ReportBlock rb;
261 rb.To(kSourceSsrc); 230 rb.To(kSourceSsrc);
262 rtcp::ReceiverReport rr; 231 rtcp::ReceiverReport rr;
263 rr.From(kSenderSsrc); 232 rr.From(kSenderSsrc);
264 rr.WithReportBlock(rb); 233 rr.WithReportBlock(rb);
265 rtc::Buffer packet = rr.Build(); 234 EXPECT_CALL(bandwidth_observer_,
266 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 235 OnReceivedRtcpReceiverReport(SizeIs(1), _, now));
267 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); 236 InjectPacket(rr);
268 EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags); 237 EXPECT_EQ(now, rtcp_receiver_->LastReceivedReceiverReport());
269 ASSERT_EQ(1u, rtcp_packet_info_.report_blocks.size());
270 238
271 std::vector<RTCPReportBlock> received_blocks; 239 std::vector<RTCPReportBlock> received_blocks;
272 rtcp_receiver_->StatisticsReceived(&received_blocks); 240 rtcp_receiver_->StatisticsReceived(&received_blocks);
273 EXPECT_EQ(1u, received_blocks.size()); 241 EXPECT_EQ(1u, received_blocks.size());
274 } 242 }
275 243
276 TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) { 244 TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) {
277 const uint32_t kSenderSsrc = 0x10203; 245 const uint32_t kSenderSsrc = 0x10203;
278 const uint32_t kSourceSsrcs[] = {0x40506, 0x50607}; 246 const uint32_t kSourceSsrcs[] = {0x40506, 0x50607};
279 const uint16_t kSequenceNumbers[] = {10, 12423}; 247 const uint16_t kSequenceNumbers[] = {10, 12423};
280 const uint32_t kCumLost[] = {13, 555}; 248 const uint32_t kCumLost[] = {13, 555};
281 const uint8_t kFracLost[] = {20, 11}; 249 const uint8_t kFracLost[] = {20, 11};
282 const int kNumSsrcs = sizeof(kSourceSsrcs) / sizeof(kSourceSsrcs[0]); 250 int64_t now = system_clock_.TimeInMilliseconds();
283 251
284 std::set<uint32_t> ssrcs(kSourceSsrcs, kSourceSsrcs + kNumSsrcs); 252 SetSsrcs(kSourceSsrcs);
285 rtcp_receiver_->SetSsrcs(kSourceSsrcs[0], ssrcs);
286 253
287 rtcp::ReportBlock rb1; 254 rtcp::ReportBlock rb1;
288 rb1.To(kSourceSsrcs[0]); 255 rb1.To(kSourceSsrcs[0]);
289 rb1.WithExtHighestSeqNum(kSequenceNumbers[0]); 256 rb1.WithExtHighestSeqNum(kSequenceNumbers[0]);
290 rb1.WithFractionLost(10); 257 rb1.WithFractionLost(10);
291 rb1.WithCumulativeLost(5); 258 rb1.WithCumulativeLost(5);
292 259
293 rtcp::ReportBlock rb2; 260 rtcp::ReportBlock rb2;
294 rb2.To(kSourceSsrcs[1]); 261 rb2.To(kSourceSsrcs[1]);
295 rb2.WithExtHighestSeqNum(kSequenceNumbers[1]); 262 rb2.WithExtHighestSeqNum(kSequenceNumbers[1]);
296 263
297 rtcp::ReceiverReport rr1; 264 rtcp::ReceiverReport rr1;
298 rr1.From(kSenderSsrc); 265 rr1.From(kSenderSsrc);
299 rr1.WithReportBlock(rb1); 266 rr1.WithReportBlock(rb1);
300 rr1.WithReportBlock(rb2); 267 rr1.WithReportBlock(rb2);
301 268
302 rtc::Buffer p1 = rr1.Build(); 269 EXPECT_CALL(bandwidth_observer_,
303 EXPECT_EQ(0, InjectRtcpPacket(p1.data(), p1.size())); 270 OnReceivedRtcpReceiverReport(SizeIs(2), _, now));
304 ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size()); 271
305 EXPECT_EQ(10, rtcp_packet_info_.report_blocks.front().fractionLost); 272 InjectPacket(rr1);
306 EXPECT_EQ(0, rtcp_packet_info_.report_blocks.back().fractionLost); 273 EXPECT_EQ(now, rtcp_receiver_->LastReceivedReceiverReport());
274
275 std::vector<RTCPReportBlock> received_blocks;
276 rtcp_receiver_->StatisticsReceived(&received_blocks);
277
278 ASSERT_EQ(2u, received_blocks.size());
279 {
280 int fraction_losts[2] = {received_blocks[0].fractionLost,
281 received_blocks[1].fractionLost};
282 EXPECT_THAT(fraction_losts, UnorderedElementsAre(0, 10));
283 }
307 284
308 rtcp::ReportBlock rb3; 285 rtcp::ReportBlock rb3;
309 rb3.To(kSourceSsrcs[0]); 286 rb3.To(kSourceSsrcs[0]);
310 rb3.WithExtHighestSeqNum(kSequenceNumbers[0]); 287 rb3.WithExtHighestSeqNum(kSequenceNumbers[0]);
311 rb3.WithFractionLost(kFracLost[0]); 288 rb3.WithFractionLost(kFracLost[0]);
312 rb3.WithCumulativeLost(kCumLost[0]); 289 rb3.WithCumulativeLost(kCumLost[0]);
313 290
314 rtcp::ReportBlock rb4; 291 rtcp::ReportBlock rb4;
315 rb4.To(kSourceSsrcs[1]); 292 rb4.To(kSourceSsrcs[1]);
316 rb4.WithExtHighestSeqNum(kSequenceNumbers[1]); 293 rb4.WithExtHighestSeqNum(kSequenceNumbers[1]);
317 rb4.WithFractionLost(kFracLost[1]); 294 rb4.WithFractionLost(kFracLost[1]);
318 rb4.WithCumulativeLost(kCumLost[1]); 295 rb4.WithCumulativeLost(kCumLost[1]);
319 296
320 rtcp::ReceiverReport rr2; 297 rtcp::ReceiverReport rr2;
321 rr2.From(kSenderSsrc); 298 rr2.From(kSenderSsrc);
322 rr2.WithReportBlock(rb3); 299 rr2.WithReportBlock(rb3);
323 rr2.WithReportBlock(rb4); 300 rr2.WithReportBlock(rb4);
324 301
325 rtc::Buffer p2 = rr2.Build(); 302 system_clock_.AdvanceTimeMilliseconds(500);
326 EXPECT_EQ(0, InjectRtcpPacket(p2.data(), p2.size())); 303 now = system_clock_.TimeInMilliseconds();
327 ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size()); 304 EXPECT_CALL(bandwidth_observer_,
328 EXPECT_EQ(kFracLost[0], rtcp_packet_info_.report_blocks.front().fractionLost); 305 OnReceivedRtcpReceiverReport(SizeIs(2), _, now));
329 EXPECT_EQ(kFracLost[1], rtcp_packet_info_.report_blocks.back().fractionLost); 306 InjectPacket(rr2);
330 307
331 std::vector<RTCPReportBlock> received_blocks; 308 received_blocks.clear();
332 rtcp_receiver_->StatisticsReceived(&received_blocks); 309 rtcp_receiver_->StatisticsReceived(&received_blocks);
333 EXPECT_EQ(2u, received_blocks.size()); 310 EXPECT_EQ(2u, received_blocks.size());
334 for (size_t i = 0; i < received_blocks.size(); ++i) { 311 EXPECT_THAT(received_blocks,
335 EXPECT_EQ(kSenderSsrc, received_blocks[i].remoteSSRC); 312 UnorderedElementsAre(
336 EXPECT_EQ(kSourceSsrcs[i], received_blocks[i].sourceSSRC); 313 AllOf(Field(&RTCPReportBlock::sourceSSRC, kSourceSsrcs[0]),
337 EXPECT_EQ(kFracLost[i], received_blocks[i].fractionLost); 314 Field(&RTCPReportBlock::fractionLost, kFracLost[0]),
338 EXPECT_EQ(kCumLost[i], received_blocks[i].cumulativeLost); 315 Field(&RTCPReportBlock::cumulativeLost, kCumLost[0]),
339 EXPECT_EQ(kSequenceNumbers[i], received_blocks[i].extendedHighSeqNum); 316 Field(&RTCPReportBlock::extendedHighSeqNum,
340 } 317 kSequenceNumbers[0])),
318 AllOf(Field(&RTCPReportBlock::sourceSSRC, kSourceSsrcs[1]),
319 Field(&RTCPReportBlock::fractionLost, kFracLost[1]),
320 Field(&RTCPReportBlock::cumulativeLost, kCumLost[1]),
321 Field(&RTCPReportBlock::extendedHighSeqNum,
322 kSequenceNumbers[1]))));
341 } 323 }
342 324
343 TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) { 325 TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) {
344 const uint32_t kSenderSsrc1 = 0x10203; 326 const uint32_t kSenderSsrc[] = {0x10203, 0x20304};
345 const uint32_t kSenderSsrc2 = 0x20304;
346 const uint32_t kSourceSsrcs[] = {0x40506, 0x50607}; 327 const uint32_t kSourceSsrcs[] = {0x40506, 0x50607};
347 const uint16_t kSequenceNumbers[] = {10, 12423}; 328 const uint16_t kSequenceNumbers[] = {10, 12423};
348 const uint32_t kCumLost[] = {13, 555}; 329 const uint32_t kCumLost[] = {13, 555};
349 const uint8_t kFracLost[] = {20, 11}; 330 const uint8_t kFracLost[] = {20, 11};
350 const int kNumSsrcs = sizeof(kSourceSsrcs) / sizeof(kSourceSsrcs[0]);
351 331
352 std::set<uint32_t> ssrcs(kSourceSsrcs, kSourceSsrcs + kNumSsrcs); 332 SetSsrcs(kSourceSsrcs);
353 rtcp_receiver_->SetSsrcs(kSourceSsrcs[0], ssrcs);
354 333
355 rtcp::ReportBlock rb1; 334 rtcp::ReportBlock rb1;
356 rb1.To(kSourceSsrcs[0]); 335 rb1.To(kSourceSsrcs[0]);
357 rb1.WithExtHighestSeqNum(kSequenceNumbers[0]); 336 rb1.WithExtHighestSeqNum(kSequenceNumbers[0]);
358 rb1.WithFractionLost(kFracLost[0]); 337 rb1.WithFractionLost(kFracLost[0]);
359 rb1.WithCumulativeLost(kCumLost[0]); 338 rb1.WithCumulativeLost(kCumLost[0]);
360 rtcp::ReceiverReport rr1; 339 rtcp::ReceiverReport rr1;
361 rr1.From(kSenderSsrc1); 340 rr1.From(kSenderSsrc[0]);
362 rr1.WithReportBlock(rb1); 341 rr1.WithReportBlock(rb1);
363 342
364 rtc::Buffer p1 = rr1.Build(); 343 int64_t now = system_clock_.TimeInMilliseconds();
365 EXPECT_EQ(0, InjectRtcpPacket(p1.data(), p1.size())); 344 EXPECT_CALL(bandwidth_observer_,
366 ASSERT_EQ(1u, rtcp_packet_info_.report_blocks.size()); 345 OnReceivedRtcpReceiverReport(SizeIs(1), _, now));
367 EXPECT_EQ(kFracLost[0], rtcp_packet_info_.report_blocks.front().fractionLost); 346 InjectPacket(rr1);
347 EXPECT_EQ(now, rtcp_receiver_->LastReceivedReceiverReport());
368 348
369 std::vector<RTCPReportBlock> received_blocks; 349 std::vector<RTCPReportBlock> received_blocks;
370 rtcp_receiver_->StatisticsReceived(&received_blocks); 350 rtcp_receiver_->StatisticsReceived(&received_blocks);
371 EXPECT_EQ(1u, received_blocks.size()); 351 EXPECT_EQ(1u, received_blocks.size());
372 EXPECT_EQ(kSenderSsrc1, received_blocks[0].remoteSSRC); 352 EXPECT_EQ(kSenderSsrc[0], received_blocks[0].remoteSSRC);
373 EXPECT_EQ(kSourceSsrcs[0], received_blocks[0].sourceSSRC); 353 EXPECT_EQ(kSourceSsrcs[0], received_blocks[0].sourceSSRC);
374 EXPECT_EQ(kFracLost[0], received_blocks[0].fractionLost); 354 EXPECT_EQ(kFracLost[0], received_blocks[0].fractionLost);
375 EXPECT_EQ(kCumLost[0], received_blocks[0].cumulativeLost); 355 EXPECT_EQ(kCumLost[0], received_blocks[0].cumulativeLost);
376 EXPECT_EQ(kSequenceNumbers[0], received_blocks[0].extendedHighSeqNum); 356 EXPECT_EQ(kSequenceNumbers[0], received_blocks[0].extendedHighSeqNum);
377 357
378 rtcp::ReportBlock rb2; 358 rtcp::ReportBlock rb2;
379 rb2.To(kSourceSsrcs[0]); 359 rb2.To(kSourceSsrcs[0]);
380 rb2.WithExtHighestSeqNum(kSequenceNumbers[1]); 360 rb2.WithExtHighestSeqNum(kSequenceNumbers[1]);
381 rb2.WithFractionLost(kFracLost[1]); 361 rb2.WithFractionLost(kFracLost[1]);
382 rb2.WithCumulativeLost(kCumLost[1]); 362 rb2.WithCumulativeLost(kCumLost[1]);
383 rtcp::ReceiverReport rr2; 363 rtcp::ReceiverReport rr2;
384 rr2.From(kSenderSsrc2); 364 rr2.From(kSenderSsrc[1]);
385 rr2.WithReportBlock(rb2); 365 rr2.WithReportBlock(rb2);
386 rtc::Buffer p2 = rr2.Build(); 366
387 EXPECT_EQ(0, InjectRtcpPacket(p2.data(), p2.size())); 367 EXPECT_CALL(bandwidth_observer_,
388 ASSERT_EQ(1u, rtcp_packet_info_.report_blocks.size()); 368 OnReceivedRtcpReceiverReport(SizeIs(1), _, now));
389 EXPECT_EQ(kFracLost[1], rtcp_packet_info_.report_blocks.front().fractionLost); 369 InjectPacket(rr2);
390 370
391 received_blocks.clear(); 371 received_blocks.clear();
392 rtcp_receiver_->StatisticsReceived(&received_blocks); 372 rtcp_receiver_->StatisticsReceived(&received_blocks);
393 ASSERT_EQ(2u, received_blocks.size()); 373 ASSERT_EQ(2u, received_blocks.size());
394 EXPECT_EQ(kSenderSsrc1, received_blocks[0].remoteSSRC); 374 // Order is not guaranteed.
395 EXPECT_EQ(kSenderSsrc2, received_blocks[1].remoteSSRC); 375 EXPECT_THAT(received_blocks,
396 for (size_t i = 0; i < received_blocks.size(); ++i) { 376 UnorderedElementsAre(
397 EXPECT_EQ(kSourceSsrcs[0], received_blocks[i].sourceSSRC); 377 AllOf(Field(&RTCPReportBlock::sourceSSRC, kSourceSsrcs[0]),
398 EXPECT_EQ(kFracLost[i], received_blocks[i].fractionLost); 378 Field(&RTCPReportBlock::remoteSSRC, kSenderSsrc[0]),
399 EXPECT_EQ(kCumLost[i], received_blocks[i].cumulativeLost); 379 Field(&RTCPReportBlock::fractionLost, kFracLost[0]),
400 EXPECT_EQ(kSequenceNumbers[i], received_blocks[i].extendedHighSeqNum); 380 Field(&RTCPReportBlock::cumulativeLost, kCumLost[0]),
401 } 381 Field(&RTCPReportBlock::extendedHighSeqNum,
382 kSequenceNumbers[0])),
383 AllOf(Field(&RTCPReportBlock::sourceSSRC, kSourceSsrcs[0]),
384 Field(&RTCPReportBlock::remoteSSRC, kSenderSsrc[1]),
385 Field(&RTCPReportBlock::fractionLost, kFracLost[1]),
386 Field(&RTCPReportBlock::cumulativeLost, kCumLost[1]),
387 Field(&RTCPReportBlock::extendedHighSeqNum,
388 kSequenceNumbers[1]))));
402 } 389 }
403 390
404 TEST_F(RtcpReceiverTest, GetRtt) { 391 TEST_F(RtcpReceiverTest, GetRtt) {
405 const uint32_t kSenderSsrc = 0x10203; 392 const uint32_t kSenderSsrc = 0x10203;
406 const uint32_t kSourceSsrc = 0x123456; 393 const uint32_t kSourceSsrc = 0x123456;
407 std::set<uint32_t> ssrcs; 394 SetSsrc(kSourceSsrc);
408 ssrcs.insert(kSourceSsrc);
409 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
410 395
411 // No report block received. 396 // No report block received.
412 EXPECT_EQ( 397 EXPECT_EQ(
413 -1, rtcp_receiver_->RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr)); 398 -1, rtcp_receiver_->RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr));
414 399
415 rtcp::ReportBlock rb; 400 rtcp::ReportBlock rb;
416 rb.To(kSourceSsrc); 401 rb.To(kSourceSsrc);
402 rb.WithLastSr(0x12344321);
417 rtcp::ReceiverReport rr; 403 rtcp::ReceiverReport rr;
418 rr.From(kSenderSsrc); 404 rr.From(kSenderSsrc);
419 rr.WithReportBlock(rb); 405 rr.WithReportBlock(rb);
420 rtc::Buffer packet = rr.Build(); 406 int64_t now = system_clock_.TimeInMilliseconds();
421 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 407 EXPECT_CALL(bandwidth_observer_,
422 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); 408 OnReceivedRtcpReceiverReport(SizeIs(1), _, now));
423 EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags); 409 InjectPacket(rr);
424 EXPECT_EQ(1u, rtcp_packet_info_.report_blocks.size()); 410 EXPECT_EQ(now, rtcp_receiver_->LastReceivedReceiverReport());
425 EXPECT_EQ( 411 EXPECT_EQ(
426 0, rtcp_receiver_->RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr)); 412 0, rtcp_receiver_->RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr));
427 413
428 // Report block not received. 414 // Report block not received.
429 EXPECT_EQ(-1, rtcp_receiver_->RTT(kSenderSsrc + 1, nullptr, nullptr, nullptr, 415 EXPECT_EQ(-1, rtcp_receiver_->RTT(kSenderSsrc + 1, nullptr, nullptr, nullptr,
430 nullptr)); 416 nullptr));
431 } 417 }
432 418
419 // Currently ij packets are ignored.
433 TEST_F(RtcpReceiverTest, InjectIjWithNoItem) { 420 TEST_F(RtcpReceiverTest, InjectIjWithNoItem) {
421 int64_t now = system_clock_.TimeInMilliseconds();
434 rtcp::ExtendedJitterReport ij; 422 rtcp::ExtendedJitterReport ij;
435 rtc::Buffer packet = ij.Build(); 423
436 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 424 InjectPacket(ij);
437 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 425 EXPECT_EQ(now, rtcp_receiver_->LastReceived());
438 } 426 }
439 427
428 // Currently ij packets are ignored.
440 TEST_F(RtcpReceiverTest, InjectIjWithOneItem) { 429 TEST_F(RtcpReceiverTest, InjectIjWithOneItem) {
430 int64_t now = system_clock_.TimeInMilliseconds();
441 rtcp::ExtendedJitterReport ij; 431 rtcp::ExtendedJitterReport ij;
442 ij.WithJitter(0x11213141); 432 ij.WithJitter(0x11213141);
443 433
444 rtc::Buffer packet = ij.Build(); 434 InjectPacket(ij);
445 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 435 EXPECT_EQ(now, rtcp_receiver_->LastReceived());
446 EXPECT_EQ(kRtcpTransmissionTimeOffset, rtcp_packet_info_.rtcpPacketTypeFlags); 436 // EXPECT_EQ(0x11213141U, rtcp_receiver->LastInterArrivalJitter());
447 EXPECT_EQ(0x11213141U, rtcp_packet_info_.interArrivalJitter);
448 } 437 }
449 438
439 // Currently app packets are ignored.
450 TEST_F(RtcpReceiverTest, InjectAppWithNoData) { 440 TEST_F(RtcpReceiverTest, InjectAppWithNoData) {
441 int64_t now = system_clock_.TimeInMilliseconds();
451 rtcp::App app; 442 rtcp::App app;
452 app.WithSubType(30); 443 app.WithSubType(30);
453 uint32_t name = 'n' << 24; 444 uint32_t name = 'n' << 24;
454 name += 'a' << 16; 445 name += 'a' << 16;
455 name += 'm' << 8; 446 name += 'm' << 8;
456 name += 'e'; 447 name += 'e';
457 app.WithName(name); 448 app.WithName(name);
458 449
459 rtc::Buffer packet = app.Build(); 450 InjectPacket(app);
460 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 451 EXPECT_EQ(now, rtcp_receiver_->LastReceived());
461 EXPECT_EQ(kRtcpApp, rtcp_packet_info_.rtcpPacketTypeFlags); 452 // EXPECT_EQ(kRtcpApp, rtcp_packet_info_.rtcpPacketTypeFlags);
462 EXPECT_EQ(30, rtcp_packet_info_.applicationSubType); 453 // EXPECT_EQ(30, rtcp_packet_info_.applicationSubType);
463 EXPECT_EQ(name, rtcp_packet_info_.applicationName); 454 // EXPECT_EQ(name, rtcp_packet_info_.applicationName);
464 EXPECT_EQ(0, rtcp_packet_info_.applicationLength); 455 // EXPECT_EQ(0, rtcp_packet_info_.applicationLength);
465 } 456 }
466 457
458 // Currently app packets are ignored.
467 TEST_F(RtcpReceiverTest, InjectAppWithData) { 459 TEST_F(RtcpReceiverTest, InjectAppWithData) {
460 int64_t now = system_clock_.TimeInMilliseconds();
468 rtcp::App app; 461 rtcp::App app;
469 app.WithSubType(30); 462 app.WithSubType(30);
470 uint32_t name = 'n' << 24; 463 uint32_t name = 'n' << 24;
471 name += 'a' << 16; 464 name += 'a' << 16;
472 name += 'm' << 8; 465 name += 'm' << 8;
473 name += 'e'; 466 name += 'e';
474 app.WithName(name); 467 app.WithName(name);
475 const char kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'}; 468 const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'};
476 const size_t kDataLength = sizeof(kData) / sizeof(kData[0]); 469 const size_t kDataLength = sizeof(kData) / sizeof(kData[0]);
477 app.WithData((const uint8_t*)kData, kDataLength); 470 app.WithData(kData, kDataLength);
478 471
479 rtc::Buffer packet = app.Build(); 472 InjectPacket(app);
480 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 473 EXPECT_EQ(now, rtcp_receiver_->LastReceived());
481 EXPECT_EQ(kRtcpApp, rtcp_packet_info_.rtcpPacketTypeFlags); 474 // EXPECT_EQ(kRtcpApp, rtcp_packet_info_.rtcpPacketTypeFlags);
482 EXPECT_EQ(30, rtcp_packet_info_.applicationSubType); 475 // EXPECT_EQ(30, rtcp_packet_info_.applicationSubType);
483 EXPECT_EQ(name, rtcp_packet_info_.applicationName); 476 // EXPECT_EQ(name, rtcp_packet_info_.applicationName);
484 EXPECT_EQ(kDataLength, rtcp_packet_info_.applicationLength); 477 // EXPECT_EQ(kDataLength, rtcp_packet_info_.applicationLength);
485 } 478 }
486 479
487 TEST_F(RtcpReceiverTest, InjectSdesWithOneChunk) { 480 TEST_F(RtcpReceiverTest, InjectSdesWithOneChunk) {
488 const uint32_t kSenderSsrc = 0x123456; 481 const uint32_t kSenderSsrc = 0x123456;
489 rtcp::Sdes sdes; 482 rtcp::Sdes sdes;
490 sdes.WithCName(kSenderSsrc, "alice@host"); 483 sdes.WithCName(kSenderSsrc, "alice@host");
484 MockRtcpCallbackImpl callback;
485 rtcp_receiver_->RegisterRtcpStatisticsCallback(&callback);
486 EXPECT_CALL(callback, CNameChanged(StrEq("alice@host"), kSenderSsrc));
491 487
492 rtc::Buffer packet = sdes.Build(); 488 InjectPacket(sdes);
493 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 489
494 char cName[RTCP_CNAME_SIZE]; 490 char cName[RTCP_CNAME_SIZE];
495 EXPECT_EQ(0, rtcp_receiver_->CNAME(kSenderSsrc, cName)); 491 EXPECT_EQ(0, rtcp_receiver_->CNAME(kSenderSsrc, cName));
496 EXPECT_EQ(0, strncmp(cName, "alice@host", RTCP_CNAME_SIZE)); 492 EXPECT_EQ(0, strncmp(cName, "alice@host", RTCP_CNAME_SIZE));
497 } 493 }
498 494
499 TEST_F(RtcpReceiverTest, InjectByePacket_RemovesCname) { 495 TEST_F(RtcpReceiverTest, InjectByePacket_RemovesCname) {
500 const uint32_t kSenderSsrc = 0x123456; 496 const uint32_t kSenderSsrc = 0x123456;
501 rtcp::Sdes sdes; 497 rtcp::Sdes sdes;
502 sdes.WithCName(kSenderSsrc, "alice@host"); 498 sdes.WithCName(kSenderSsrc, "alice@host");
503 499
504 rtc::Buffer packet = sdes.Build(); 500 InjectPacket(sdes);
505 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
506 char cName[RTCP_CNAME_SIZE]; 501 char cName[RTCP_CNAME_SIZE];
507 EXPECT_EQ(0, rtcp_receiver_->CNAME(kSenderSsrc, cName)); 502 EXPECT_EQ(0, rtcp_receiver_->CNAME(kSenderSsrc, cName));
508 503
509 // Verify that BYE removes the CNAME. 504 // Verify that BYE removes the CNAME.
510 rtcp::Bye bye; 505 rtcp::Bye bye;
511 bye.From(kSenderSsrc); 506 bye.From(kSenderSsrc);
512 rtc::Buffer p2 = bye.Build(); 507 InjectPacket(bye);
513 EXPECT_EQ(0, InjectRtcpPacket(p2.data(), p2.size()));
514 EXPECT_EQ(-1, rtcp_receiver_->CNAME(kSenderSsrc, cName)); 508 EXPECT_EQ(-1, rtcp_receiver_->CNAME(kSenderSsrc, cName));
515 } 509 }
516 510
517 TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) { 511 TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) {
518 const uint32_t kSenderSsrc = 0x10203; 512 const uint32_t kSenderSsrc = 0x10203;
519 const uint32_t kSourceSsrcs[] = {0x40506, 0x50607}; 513 const uint32_t kSourceSsrcs[] = {0x40506, 0x50607};
520 const int kNumSsrcs = sizeof(kSourceSsrcs) / sizeof(kSourceSsrcs[0]);
521 514
522 std::set<uint32_t> ssrcs(kSourceSsrcs, kSourceSsrcs + kNumSsrcs); 515 SetSsrcs(kSourceSsrcs);
523 rtcp_receiver_->SetSsrcs(kSourceSsrcs[0], ssrcs);
524 516
525 rtcp::ReportBlock rb1; 517 rtcp::ReportBlock rb1;
526 rb1.To(kSourceSsrcs[0]); 518 rb1.To(kSourceSsrcs[0]);
527 rtcp::ReportBlock rb2; 519 rtcp::ReportBlock rb2;
528 rb2.To(kSourceSsrcs[1]); 520 rb2.To(kSourceSsrcs[1]);
529 rtcp::ReceiverReport rr; 521 rtcp::ReceiverReport rr;
530 rr.From(kSenderSsrc); 522 rr.From(kSenderSsrc);
531 rr.WithReportBlock(rb1); 523 rr.WithReportBlock(rb1);
532 rr.WithReportBlock(rb2); 524 rr.WithReportBlock(rb2);
533 525
534 rtc::Buffer p1 = rr.Build(); 526 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
535 EXPECT_EQ(0, InjectRtcpPacket(p1.data(), p1.size())); 527 InjectPacket(rr);
536 ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size());
537 std::vector<RTCPReportBlock> received_blocks; 528 std::vector<RTCPReportBlock> received_blocks;
538 rtcp_receiver_->StatisticsReceived(&received_blocks); 529 rtcp_receiver_->StatisticsReceived(&received_blocks);
539 EXPECT_EQ(2u, received_blocks.size()); 530 EXPECT_EQ(2u, received_blocks.size());
540 531
541 // Verify that BYE removes the report blocks. 532 // Verify that BYE removes the report blocks.
542 rtcp::Bye bye; 533 rtcp::Bye bye;
543 bye.From(kSenderSsrc); 534 bye.From(kSenderSsrc);
544 rtc::Buffer p2 = bye.Build(); 535 InjectPacket(bye);
545 EXPECT_EQ(0, InjectRtcpPacket(p2.data(), p2.size()));
546 received_blocks.clear(); 536 received_blocks.clear();
547 rtcp_receiver_->StatisticsReceived(&received_blocks); 537 rtcp_receiver_->StatisticsReceived(&received_blocks);
548 EXPECT_TRUE(received_blocks.empty()); 538 EXPECT_TRUE(received_blocks.empty());
549 539
550 // Inject packet. 540 // Inject packet.
551 EXPECT_EQ(0, InjectRtcpPacket(p1.data(), p1.size())); 541 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
552 ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size()); 542 InjectPacket(rr);
553 received_blocks.clear(); 543 received_blocks.clear();
554 rtcp_receiver_->StatisticsReceived(&received_blocks); 544 rtcp_receiver_->StatisticsReceived(&received_blocks);
555 EXPECT_EQ(2u, received_blocks.size()); 545 EXPECT_EQ(2u, received_blocks.size());
556 } 546 }
557 547
558 TEST_F(RtcpReceiverTest, InjectPliPacket) { 548 TEST_F(RtcpReceiverTest, InjectPliPacket) {
559 const uint32_t kSourceSsrc = 0x123456; 549 const uint32_t kSourceSsrc = 0x123456;
560 std::set<uint32_t> ssrcs; 550 SetSsrc(kSourceSsrc);
561 ssrcs.insert(kSourceSsrc);
562 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
563 551
564 rtcp::Pli pli; 552 rtcp::Pli pli;
565 pli.To(kSourceSsrc); 553 pli.To(kSourceSsrc);
566 rtc::Buffer packet = pli.Build(); 554 EXPECT_CALL(packet_type_counter_observer_,
567 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 555 RtcpPacketTypesCounterUpdated(
568 EXPECT_EQ(kRtcpPli, rtcp_packet_info_.rtcpPacketTypeFlags); 556 kSourceSsrc, Field(&RtcpPacketTypeCounter::pli_packets, 1)));
557 EXPECT_CALL(intra_frame_observer_, OnReceivedIntraFrameRequest(kSourceSsrc));
558 InjectPacket(pli);
569 } 559 }
570 560
571 TEST_F(RtcpReceiverTest, PliPacketNotToUsIgnored) { 561 TEST_F(RtcpReceiverTest, PliPacketNotToUsIgnored) {
572 const uint32_t kSourceSsrc = 0x123456; 562 const uint32_t kSourceSsrc = 0x123456;
573 std::set<uint32_t> ssrcs; 563 SetSsrc(kSourceSsrc);
574 ssrcs.insert(kSourceSsrc);
575 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
576 564
577 rtcp::Pli pli; 565 rtcp::Pli pli;
578 pli.To(kSourceSsrc + 1); 566 pli.To(kSourceSsrc + 1);
579 rtc::Buffer packet = pli.Build(); 567 EXPECT_CALL(packet_type_counter_observer_,
580 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 568 RtcpPacketTypesCounterUpdated(
581 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 569 kSourceSsrc, Field(&RtcpPacketTypeCounter::pli_packets, 0)));
570 EXPECT_CALL(intra_frame_observer_, OnReceivedIntraFrameRequest(_)).Times(0);
571 InjectPacket(pli);
582 } 572 }
583 573
584 TEST_F(RtcpReceiverTest, InjectFirPacket) { 574 TEST_F(RtcpReceiverTest, InjectFirPacket) {
585 const uint32_t kSourceSsrc = 0x123456; 575 const uint32_t kSourceSsrc = 0x123456;
586 std::set<uint32_t> ssrcs; 576 SetSsrc(kSourceSsrc);
587 ssrcs.insert(kSourceSsrc);
588 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
589 577
590 rtcp::Fir fir; 578 rtcp::Fir fir;
591 fir.WithRequestTo(kSourceSsrc, 13); 579 fir.WithRequestTo(kSourceSsrc, 13);
592 rtc::Buffer packet = fir.Build(); 580 EXPECT_CALL(packet_type_counter_observer_,
593 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 581 RtcpPacketTypesCounterUpdated(
594 EXPECT_EQ(kRtcpFir, rtcp_packet_info_.rtcpPacketTypeFlags); 582 kSourceSsrc, Field(&RtcpPacketTypeCounter::fir_packets, 1)));
583 EXPECT_CALL(intra_frame_observer_, OnReceivedIntraFrameRequest(kSourceSsrc));
584 InjectPacket(fir);
595 } 585 }
596 586
597 TEST_F(RtcpReceiverTest, FirPacketNotToUsIgnored) { 587 TEST_F(RtcpReceiverTest, FirPacketNotToUsIgnored) {
598 const uint32_t kSourceSsrc = 0x123456; 588 const uint32_t kSourceSsrc = 0x123456;
599 std::set<uint32_t> ssrcs; 589 SetSsrc(kSourceSsrc);
600 ssrcs.insert(kSourceSsrc);
601 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
602 590
603 rtcp::Fir fir; 591 rtcp::Fir fir;
604 fir.WithRequestTo(kSourceSsrc + 1, 13); 592 fir.WithRequestTo(kSourceSsrc + 1, 13);
605 rtc::Buffer packet = fir.Build(); 593 EXPECT_CALL(intra_frame_observer_, OnReceivedIntraFrameRequest(kSourceSsrc))
606 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 594 .Times(0);
607 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 595 InjectPacket(fir);
608 } 596 }
609 597
610 TEST_F(RtcpReceiverTest, InjectSliPacket) { 598 TEST_F(RtcpReceiverTest, InjectSliPacket) {
611 rtcp::Sli sli; 599 rtcp::Sli sli;
612 sli.WithPictureId(40); 600 sli.WithPictureId(40);
613 rtc::Buffer packet = sli.Build(); 601 EXPECT_CALL(intra_frame_observer_, OnReceivedSLI(_, 40));
614 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 602 InjectPacket(sli);
615 EXPECT_EQ(kRtcpSli, rtcp_packet_info_.rtcpPacketTypeFlags); 603 }
616 EXPECT_EQ(40, rtcp_packet_info_.sliPictureId); 604
605 TEST_F(RtcpReceiverTest, InjectRPsiPacket) {
606 const uint64_t kPictureId = 0x123456789;
607 rtcp::Rpsi rpsi;
608 rpsi.WithPictureId(kPictureId);
609 EXPECT_CALL(intra_frame_observer_, OnReceivedRPSI(_, kPictureId));
610 InjectPacket(rpsi);
617 } 611 }
618 612
619 TEST_F(RtcpReceiverTest, ExtendedReportsPacketWithZeroReportBlocksIgnored) { 613 TEST_F(RtcpReceiverTest, ExtendedReportsPacketWithZeroReportBlocksIgnored) {
620 rtcp::ExtendedReports xr; 614 rtcp::ExtendedReports xr;
621 xr.From(0x2345); 615 xr.From(0x2345);
622 rtc::Buffer packet = xr.Build(); 616 InjectPacket(xr);
623 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
624 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags);
625 } 617 }
626 618
619 // Currently VOiP reports are ignored.
627 TEST_F(RtcpReceiverTest, InjectExtendedReportsVoipPacket) { 620 TEST_F(RtcpReceiverTest, InjectExtendedReportsVoipPacket) {
628 const uint32_t kSourceSsrc = 0x123456; 621 const uint32_t kSourceSsrc = 0x123456;
629 std::set<uint32_t> ssrcs; 622 SetSsrc(kSourceSsrc);
630 ssrcs.insert(kSourceSsrc);
631 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
632 623
633 const uint8_t kLossRate = 123; 624 const uint8_t kLossRate = 123;
634 rtcp::VoipMetric voip_metric; 625 rtcp::VoipMetric voip_metric;
635 voip_metric.To(kSourceSsrc); 626 voip_metric.To(kSourceSsrc);
636 RTCPVoIPMetric metric; 627 RTCPVoIPMetric metric;
637 metric.lossRate = kLossRate; 628 metric.lossRate = kLossRate;
638 voip_metric.WithVoipMetric(metric); 629 voip_metric.WithVoipMetric(metric);
639 rtcp::ExtendedReports xr; 630 rtcp::ExtendedReports xr;
640 xr.From(0x2345); 631 xr.From(0x2345);
641 xr.WithVoipMetric(voip_metric); 632 xr.WithVoipMetric(voip_metric);
642 rtc::Buffer packet = xr.Build(); 633
643 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 634 InjectPacket(xr);
644 ASSERT_TRUE(rtcp_packet_info_.VoIPMetric != nullptr);
645 EXPECT_EQ(kLossRate, rtcp_packet_info_.VoIPMetric->lossRate);
646 EXPECT_EQ(kRtcpXrVoipMetric, rtcp_packet_info_.rtcpPacketTypeFlags);
647 } 635 }
648 636
637 // Currently VOiP reports are ignored.
649 TEST_F(RtcpReceiverTest, ExtendedReportsVoipPacketNotToUsIgnored) { 638 TEST_F(RtcpReceiverTest, ExtendedReportsVoipPacketNotToUsIgnored) {
650 const uint32_t kSourceSsrc = 0x123456; 639 const uint32_t kSourceSsrc = 0x123456;
651 std::set<uint32_t> ssrcs; 640 SetSsrc(kSourceSsrc);
652 ssrcs.insert(kSourceSsrc);
653 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
654 641
655 rtcp::VoipMetric voip_metric; 642 rtcp::VoipMetric voip_metric;
656 voip_metric.To(kSourceSsrc + 1); 643 voip_metric.To(kSourceSsrc + 1);
657 rtcp::ExtendedReports xr; 644 rtcp::ExtendedReports xr;
658 xr.From(0x2345); 645 xr.From(0x2345);
659 xr.WithVoipMetric(voip_metric); 646 xr.WithVoipMetric(voip_metric);
660 rtc::Buffer packet = xr.Build(); 647
661 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 648 InjectPacket(xr);
662 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags);
663 } 649 }
664 650
665 TEST_F(RtcpReceiverTest, InjectExtendedReportsReceiverReferenceTimePacket) { 651 TEST_F(RtcpReceiverTest, InjectExtendedReportsReceiverReferenceTimePacket) {
652 const NtpTime kNtp(0x10203, 0x40506);
653 const uint32_t kSenderSsrc = 0x2345;
666 rtcp::Rrtr rrtr; 654 rtcp::Rrtr rrtr;
667 rrtr.WithNtp(NtpTime(0x10203, 0x40506)); 655 rrtr.WithNtp(kNtp);
668 rtcp::ExtendedReports xr; 656 rtcp::ExtendedReports xr;
669 xr.From(0x2345); 657 xr.From(kSenderSsrc);
670 xr.WithRrtr(rrtr); 658 xr.WithRrtr(rrtr);
671 659
672 rtc::Buffer packet = xr.Build(); 660 RtcpReceiveTimeInfo rrtime;
673 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 661 EXPECT_FALSE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&rrtime));
674 EXPECT_EQ(kRtcpXrReceiverReferenceTime, 662 InjectPacket(xr);
675 rtcp_packet_info_.rtcpPacketTypeFlags); 663
664 EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&rrtime));
665 EXPECT_EQ(rrtime.sourceSSRC, kSenderSsrc);
666 EXPECT_EQ(rrtime.lastRR, CompactNtp(kNtp));
667 EXPECT_EQ(0u, CompactNtpIntervalToMs(rrtime.delaySinceLastRR));
668
669 system_clock_.AdvanceTimeMilliseconds(1500);
670
671 EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&rrtime));
672 EXPECT_NEAR(1500, CompactNtpIntervalToMs(rrtime.delaySinceLastRR), 1);
676 } 673 }
677 674
678 TEST_F(RtcpReceiverTest, ExtendedReportsDlrrPacketNotToUsIgnored) { 675 TEST_F(RtcpReceiverTest, ExtendedReportsDlrrPacketNotToUsIgnored) {
679 const uint32_t kSourceSsrc = 0x123456; 676 const uint32_t kSourceSsrc = 0x123456;
680 std::set<uint32_t> ssrcs; 677 SetSsrc(kSourceSsrc);
681 ssrcs.insert(kSourceSsrc);
682 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
683 678
684 rtcp::Dlrr dlrr; 679 rtcp::Dlrr dlrr;
685 dlrr.WithDlrrItem(kSourceSsrc + 1, 0x12345, 0x67890); 680 dlrr.WithDlrrItem(kSourceSsrc + 1, 0x12345, 0x67890);
686 rtcp::ExtendedReports xr; 681 rtcp::ExtendedReports xr;
687 xr.From(0x2345); 682 xr.From(0x2345);
688 xr.WithDlrr(dlrr); 683 xr.WithDlrr(dlrr);
689 rtc::Buffer packet = xr.Build(); 684 InjectPacket(xr);
690 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 685 int64_t rtt_ms = 0;
691 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); 686 EXPECT_FALSE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms));
692 EXPECT_FALSE(rtcp_packet_info_.xr_dlrr_item);
693 } 687 }
694 688
695 TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) { 689 TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) {
696 const uint32_t kSourceSsrc = 0x123456; 690 const uint32_t kSourceSsrc = 0x123456;
697 std::set<uint32_t> ssrcs; 691 const uint32_t kLastRR = 0x12345;
698 ssrcs.insert(kSourceSsrc); 692 const uint32_t kDelay = 0x23456;
699 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 693 SetSsrc(kSourceSsrc);
694 int64_t rtt_ms = 0;
700 695
701 rtcp::Dlrr dlrr; 696 rtcp::Dlrr dlrr;
702 dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890); 697 dlrr.WithDlrrItem(kSourceSsrc, kLastRR, kDelay);
703 rtcp::ExtendedReports xr; 698 rtcp::ExtendedReports xr;
704 xr.From(0x2345); 699 xr.From(0x2345);
705 xr.WithDlrr(dlrr); 700 xr.WithDlrr(dlrr);
706 rtc::Buffer packet = xr.Build(); 701
707 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 702 EXPECT_FALSE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms));
708 // The parser should note the DLRR report block item. 703 InjectPacket(xr);
709 EXPECT_TRUE(rtcp_packet_info_.xr_dlrr_item); 704
705 uint32_t compact_ntp_now = CompactNtp(NtpTime(system_clock_));
706 EXPECT_TRUE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms));
707 uint32_t rtt_ntp = compact_ntp_now - kDelay - kLastRR;
708 EXPECT_NEAR(CompactNtpIntervalToMs(rtt_ntp), rtt_ms, 1);
710 } 709 }
711 710
712 TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) { 711 TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) {
713 const uint32_t kSourceSsrc = 0x123456; 712 const uint32_t kSourceSsrc = 0x123456;
714 std::set<uint32_t> ssrcs; 713 const uint32_t kLastRR = 0x12345;
715 ssrcs.insert(kSourceSsrc); 714 const uint32_t kDelay = 0x56789;
716 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); 715 SetSsrc(kSourceSsrc);
717 716
718 rtcp::Dlrr dlrr; 717 rtcp::Dlrr dlrr;
718 dlrr.WithDlrrItem(kSourceSsrc, kLastRR, kDelay);
719 dlrr.WithDlrrItem(kSourceSsrc + 1, 0x12345, 0x67890); 719 dlrr.WithDlrrItem(kSourceSsrc + 1, 0x12345, 0x67890);
720 dlrr.WithDlrrItem(kSourceSsrc + 2, 0x12345, 0x67890); 720 dlrr.WithDlrrItem(kSourceSsrc + 2, 0x12345, 0x67890);
721 dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890); 721
722 rtcp::ExtendedReports xr; 722 rtcp::ExtendedReports xr;
723 xr.From(0x2345); 723 xr.From(0x2345);
724 xr.WithDlrr(dlrr); 724 xr.WithDlrr(dlrr);
725 rtc::Buffer packet = xr.Build(); 725
726 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 726 InjectPacket(xr);
727 // The parser should note the DLRR report block item. 727 uint32_t compact_ntp_now = CompactNtp(NtpTime(system_clock_));
728 EXPECT_TRUE(rtcp_packet_info_.xr_dlrr_item); 728 int64_t rtt_ms = 0;
729 EXPECT_TRUE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms));
730 uint32_t rtt_ntp = compact_ntp_now - kDelay - kLastRR;
731 EXPECT_NEAR(CompactNtpIntervalToMs(rtt_ntp), rtt_ms, 1);
729 } 732 }
730 733
731 TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) { 734 TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) {
732 const uint32_t kSourceSsrc = 0x123456; 735 const uint32_t kSourceSsrc = 0x123456;
733 std::set<uint32_t> ssrcs; 736 SetSsrc(kSourceSsrc);
734 ssrcs.insert(kSourceSsrc);
735 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
736 737
737 rtcp::Rrtr rrtr; 738 rtcp::Rrtr rrtr;
738 rtcp::Dlrr dlrr; 739 rtcp::Dlrr dlrr;
739 dlrr.WithDlrrItem(kSourceSsrc, 0, 0x67890); 740 dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890);
740 rtcp::VoipMetric metric; 741 rtcp::VoipMetric metric;
741 metric.To(kSourceSsrc); 742 metric.To(kSourceSsrc);
742 rtcp::ExtendedReports xr; 743 rtcp::ExtendedReports xr;
743 xr.From(0x2345); 744 xr.From(0x2345);
744 xr.WithRrtr(rrtr); 745 xr.WithRrtr(rrtr);
745 xr.WithDlrr(dlrr); 746 xr.WithDlrr(dlrr);
746 xr.WithVoipMetric(metric); 747 xr.WithVoipMetric(metric);
747 rtc::Buffer packet = xr.Build(); 748
748 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 749 InjectPacket(xr);
749 // The parser should not flag the packet since the RTT is not estimated. 750
750 EXPECT_EQ(static_cast<unsigned int>(kRtcpXrReceiverReferenceTime + 751 RtcpReceiveTimeInfo rrtime;
751 kRtcpXrVoipMetric), 752 EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&rrtime));
752 rtcp_packet_info_.rtcpPacketTypeFlags); 753 int64_t rtt_ms = 0;
753 // The parser should note the DLRR report block item. 754 EXPECT_TRUE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms));
754 EXPECT_TRUE(rtcp_packet_info_.xr_dlrr_item);
755 } 755 }
756 756
757 TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) { 757 TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) {
758 const uint32_t kSourceSsrc = 0x123456; 758 const uint32_t kSourceSsrc = 0x123456;
759 std::set<uint32_t> ssrcs; 759 SetSsrc(kSourceSsrc);
760 ssrcs.insert(kSourceSsrc);
761 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
762 std::vector<uint32_t> remote_ssrcs;
763 remote_ssrcs.push_back(kSourceSsrc);
764 760
765 rtcp::Rrtr rrtr; 761 rtcp::Rrtr rrtr;
766 rtcp::Dlrr dlrr; 762 rtcp::Dlrr dlrr;
767 dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890); 763 dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890);
768 rtcp::VoipMetric metric; 764 rtcp::VoipMetric metric;
769 metric.To(kSourceSsrc); 765 metric.To(kSourceSsrc);
770 rtcp::ExtendedReports xr; 766 rtcp::ExtendedReports xr;
771 xr.From(0x2345); 767 xr.From(0x2345);
768 xr.WithDlrr(dlrr);
772 xr.WithRrtr(rrtr); 769 xr.WithRrtr(rrtr);
773 xr.WithDlrr(dlrr); 770
774 xr.WithVoipMetric(metric);
775 rtc::Buffer packet = xr.Build(); 771 rtc::Buffer packet = xr.Build();
776 // Modify the DLRR block to have an unsupported block type, from 5 to 6. 772 // Modify the DLRR block to have an unsupported block type, from 5 to 6.
777 uint8_t* buffer = packet.data(); 773 ASSERT_EQ(5, packet.data()[20]);
778 EXPECT_EQ(5, buffer[20]); 774 packet.data()[20] = 6;
779 buffer[20] = 6; 775 EXPECT_TRUE(rtcp_receiver_->IncomingPacket(packet.data(), packet.size()));
780 776
781 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 777 // Validate Rrtr was received and processed.
782 EXPECT_EQ(static_cast<unsigned int>(kRtcpXrReceiverReferenceTime + 778 RtcpReceiveTimeInfo rrtime;
783 kRtcpXrVoipMetric), 779 EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&rrtime));
784 rtcp_packet_info_.rtcpPacketTypeFlags); 780 // Validate Dlrr report wasn't processed.
785 EXPECT_FALSE(rtcp_packet_info_.xr_dlrr_item); 781 int64_t rtt_ms = 0;
782 EXPECT_FALSE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms));
786 } 783 }
787 784
788 TEST_F(RtcpReceiverTest, TestXrRrRttInitiallyFalse) { 785 TEST_F(RtcpReceiverTest, TestExtendedReportsRrRttInitiallyFalse) {
789 int64_t rtt_ms; 786 int64_t rtt_ms;
790 EXPECT_FALSE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms)); 787 EXPECT_FALSE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms));
791 } 788 }
792 789
793 TEST_F(RtcpReceiverTest, RttCalculatedAfterXrDlrr) { 790 TEST_F(RtcpReceiverTest, RttCalculatedAfterExtendedReportsDlrr) {
794 Random rand(0x0123456789abcdef); 791 Random rand(0x0123456789abcdef);
795 const uint32_t kSourceSsrc = rand.Rand(0x00000001u, 0xfffffffeu); 792 const uint32_t kSourceSsrc = rand.Rand(0x00000001u, 0xfffffffeu);
796 const uint32_t kRttMs = rand.Rand(1, 18 * 3600 * 1000); 793 const uint32_t kRttMs = rand.Rand(1, 18 * 3600 * 1000);
797 const uint32_t kDelayNtp = rand.Rand<uint32_t>(); 794 const uint32_t kDelayNtp = rand.Rand<uint32_t>();
798 const uint32_t kDelayMs = CompactNtpIntervalToMs(kDelayNtp); 795 const uint32_t kDelayMs = CompactNtpIntervalToMs(kDelayNtp);
799 std::set<uint32_t> ssrcs; 796
800 ssrcs.insert(kSourceSsrc); 797 SetSsrc(kSourceSsrc);
801 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
802 NtpTime now(system_clock_); 798 NtpTime now(system_clock_);
803 uint32_t sent_ntp = CompactNtp(now); 799 uint32_t sent_ntp = CompactNtp(now);
804 system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); 800 system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
805 801
806 rtcp::Dlrr dlrr; 802 rtcp::Dlrr dlrr;
807 dlrr.WithDlrrItem(kSourceSsrc, sent_ntp, kDelayNtp); 803 dlrr.WithDlrrItem(kSourceSsrc, sent_ntp, kDelayNtp);
808 rtcp::ExtendedReports xr; 804 rtcp::ExtendedReports xr;
809 xr.From(0x2345); 805 xr.From(0x2345);
810 xr.WithDlrr(dlrr); 806 xr.WithDlrr(dlrr);
811 rtc::Buffer packet = xr.Build(); 807 InjectPacket(xr);
812 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
813 808
814 int64_t rtt_ms = 0; 809 int64_t rtt_ms = 0;
815 EXPECT_TRUE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms)); 810 EXPECT_TRUE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms));
816 EXPECT_NEAR(kRttMs, rtt_ms, 1); 811 EXPECT_NEAR(kRttMs, rtt_ms, 1);
817 } 812 }
818 813
819 TEST_F(RtcpReceiverTest, LastReceivedXrReferenceTimeInfoInitiallyFalse) { 814 TEST_F(RtcpReceiverTest, LastReceivedXrReferenceTimeInfoInitiallyFalse) {
820 RtcpReceiveTimeInfo info; 815 RtcpReceiveTimeInfo info;
821 EXPECT_FALSE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info)); 816 EXPECT_FALSE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info));
822 } 817 }
823 818
824 TEST_F(RtcpReceiverTest, GetLastReceivedExtendedReportsReferenceTimeInfo) { 819 TEST_F(RtcpReceiverTest, GetLastReceivedExtendedReportsReferenceTimeInfo) {
825 const uint32_t kSenderSsrc = 0x123456; 820 const uint32_t kSenderSsrc = 0x123456;
826 const NtpTime kNtp(0x10203, 0x40506); 821 const NtpTime kNtp(0x10203, 0x40506);
827 const uint32_t kNtpMid = CompactNtp(kNtp); 822 const uint32_t kNtpMid = CompactNtp(kNtp);
828 823
829 rtcp::Rrtr rrtr; 824 rtcp::Rrtr rrtr;
830 rrtr.WithNtp(kNtp); 825 rrtr.WithNtp(kNtp);
831 rtcp::ExtendedReports xr; 826 rtcp::ExtendedReports xr;
832 xr.From(kSenderSsrc); 827 xr.From(kSenderSsrc);
833 xr.WithRrtr(rrtr); 828 xr.WithRrtr(rrtr);
834 rtc::Buffer packet = xr.Build(); 829
835 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 830 InjectPacket(xr);
836 EXPECT_EQ(kRtcpXrReceiverReferenceTime,
837 rtcp_packet_info_.rtcpPacketTypeFlags);
838 831
839 RtcpReceiveTimeInfo info; 832 RtcpReceiveTimeInfo info;
840 EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info)); 833 EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info));
841 EXPECT_EQ(kSenderSsrc, info.sourceSSRC); 834 EXPECT_EQ(kSenderSsrc, info.sourceSSRC);
842 EXPECT_EQ(kNtpMid, info.lastRR); 835 EXPECT_EQ(kNtpMid, info.lastRR);
843 EXPECT_EQ(0U, info.delaySinceLastRR); 836 EXPECT_EQ(0U, info.delaySinceLastRR);
844 837
845 system_clock_.AdvanceTimeMilliseconds(1000); 838 system_clock_.AdvanceTimeMilliseconds(1000);
846 EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info)); 839 EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info));
847 EXPECT_EQ(65536U, info.delaySinceLastRR); 840 EXPECT_EQ(65536U, info.delaySinceLastRR);
848 } 841 }
849 842
850 TEST_F(RtcpReceiverTest, ReceiveReportTimeout) { 843 TEST_F(RtcpReceiverTest, ReceiveReportTimeout) {
851 const uint32_t kSenderSsrc = 0x10203; 844 const uint32_t kSenderSsrc = 0x10203;
852 const uint32_t kSourceSsrc = 0x40506; 845 const uint32_t kSourceSsrc = 0x40506;
853 const int64_t kRtcpIntervalMs = 1000; 846 const int64_t kRtcpIntervalMs = 1000;
854 847
855 std::set<uint32_t> ssrcs; 848 SetSsrc(kSourceSsrc);
856 ssrcs.insert(kSourceSsrc);
857 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
858 849
859 const uint16_t kSequenceNumber = 1234; 850 const uint16_t kSequenceNumber = 1234;
860 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs); 851 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs);
861 852
862 // No RR received, shouldn't trigger a timeout. 853 // No RR received, shouldn't trigger a timeout.
863 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 854 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
864 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 855 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
865 856
866 // Add a RR and advance the clock just enough to not trigger a timeout. 857 // Add a RR and advance the clock just enough to not trigger a timeout.
867 rtcp::ReportBlock rb1; 858 rtcp::ReportBlock rb1;
868 rb1.To(kSourceSsrc); 859 rb1.To(kSourceSsrc);
869 rb1.WithExtHighestSeqNum(kSequenceNumber); 860 rb1.WithExtHighestSeqNum(kSequenceNumber);
870 rtcp::ReceiverReport rr1; 861 rtcp::ReceiverReport rr1;
871 rr1.From(kSenderSsrc); 862 rr1.From(kSenderSsrc);
872 rr1.WithReportBlock(rb1); 863 rr1.WithReportBlock(rb1);
873 rtc::Buffer p1 = rr1.Build(); 864
874 EXPECT_EQ(0, InjectRtcpPacket(p1.data(), p1.size())); 865 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
866 InjectPacket(rr1);
875 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs - 1); 867 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs - 1);
876 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 868 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
877 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 869 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
878 870
879 // Add a RR with the same extended max as the previous RR to trigger a 871 // Add a RR with the same extended max as the previous RR to trigger a
880 // sequence number timeout, but not a RR timeout. 872 // sequence number timeout, but not a RR timeout.
881 EXPECT_EQ(0, InjectRtcpPacket(p1.data(), p1.size())); 873 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
874 InjectPacket(rr1);
882 system_clock_.AdvanceTimeMilliseconds(2); 875 system_clock_.AdvanceTimeMilliseconds(2);
883 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 876 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
884 EXPECT_TRUE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 877 EXPECT_TRUE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
885 878
886 // Advance clock enough to trigger an RR timeout too. 879 // Advance clock enough to trigger an RR timeout too.
887 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs); 880 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs);
888 EXPECT_TRUE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 881 EXPECT_TRUE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
889 882
890 // We should only get one timeout even though we still haven't received a new 883 // We should only get one timeout even though we still haven't received a new
891 // RR. 884 // RR.
892 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 885 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
893 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 886 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
894 887
895 // Add a new RR with increase sequence number to reset timers. 888 // Add a new RR with increase sequence number to reset timers.
896 rtcp::ReportBlock rb2; 889 rtcp::ReportBlock rb2;
897 rb2.To(kSourceSsrc); 890 rb2.To(kSourceSsrc);
898 rb2.WithExtHighestSeqNum(kSequenceNumber + 1); 891 rb2.WithExtHighestSeqNum(kSequenceNumber + 1);
899 rtcp::ReceiverReport rr2; 892 rtcp::ReceiverReport rr2;
900 rr2.From(kSenderSsrc); 893 rr2.From(kSenderSsrc);
901 rr2.WithReportBlock(rb2); 894 rr2.WithReportBlock(rb2);
902 rtc::Buffer p2 = rr2.Build(); 895 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
903 EXPECT_EQ(0, InjectRtcpPacket(p2.data(), p2.size())); 896 InjectPacket(rr2);
904 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 897 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
905 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 898 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
906 899
907 // Verify we can get a timeout again once we've received new RR. 900 // Verify we can get a timeout again once we've received new RR.
908 system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs); 901 system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs);
909 EXPECT_EQ(0, InjectRtcpPacket(p2.data(), p2.size())); 902 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
903 InjectPacket(rr2);
910 system_clock_.AdvanceTimeMilliseconds(kRtcpIntervalMs + 1); 904 system_clock_.AdvanceTimeMilliseconds(kRtcpIntervalMs + 1);
911 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 905 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
912 EXPECT_TRUE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); 906 EXPECT_TRUE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
913 system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs); 907 system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs);
914 EXPECT_TRUE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); 908 EXPECT_TRUE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
915 } 909 }
916 910
917 TEST_F(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) { 911 TEST_F(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) {
918 // This call is expected to fail because no data has arrived. 912 // This call is expected to fail because no data has arrived.
919 EXPECT_EQ(-1, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); 913 EXPECT_EQ(-1, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
920 } 914 }
921 915
922 TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) { 916 TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) {
923 const uint32_t kMediaFlowSsrc = 0x2040608; 917 const uint32_t kMediaFlowSsrc = 0x2040608;
924 const uint32_t kSenderSsrc = 0x10203; 918 const uint32_t kSenderSsrc = 0x10203;
925 std::set<uint32_t> ssrcs; 919 SetSsrc(kMediaFlowSsrc);
926 ssrcs.insert(kMediaFlowSsrc); // Matches "media source" above.
927 rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs);
928 920
929 rtcp::Tmmbr tmmbr; 921 rtcp::Tmmbr tmmbr;
930 tmmbr.From(kSenderSsrc); 922 tmmbr.From(kSenderSsrc);
931 tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc, 30000, 0)); 923 tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc, 30000, 0));
932 924
933 rtcp::SenderReport sr; 925 rtcp::SenderReport sr;
934 sr.From(kSenderSsrc); 926 sr.From(kSenderSsrc);
935 sr.Append(&tmmbr); 927 sr.Append(&tmmbr);
936 rtc::Buffer packet = sr.Build(); 928 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
937 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 929 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(30000));
930 InjectPacket(sr);
938 931
939 EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); 932 EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
940 TMMBRSet candidate_set; 933 TMMBRSet candidate_set;
941 candidate_set.VerifyAndAllocateSet(1); 934 candidate_set.VerifyAndAllocateSet(1);
942 EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(1, 0, &candidate_set)); 935 EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(1, 0, &candidate_set));
943 EXPECT_LT(0U, candidate_set.Tmmbr(0)); 936 EXPECT_LT(0U, candidate_set.Tmmbr(0));
944 EXPECT_EQ(kSenderSsrc, candidate_set.Ssrc(0)); 937 EXPECT_EQ(kSenderSsrc, candidate_set.Ssrc(0));
945 } 938 }
946 939
947 TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) { 940 TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) {
948 const uint32_t kMediaFlowSsrc = 0x2040608; 941 const uint32_t kMediaFlowSsrc = 0x2040608;
949 const uint32_t kSenderSsrc = 0x10203; 942 const uint32_t kSenderSsrc = 0x10203;
950 943
951 rtcp::Tmmbr tmmbr; 944 rtcp::Tmmbr tmmbr;
952 tmmbr.From(kSenderSsrc); 945 tmmbr.From(kSenderSsrc);
953 // This SSRC is not what we are sending. 946 // This SSRC is not what we are sending.
954 tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc + 1, 30000, 0)); 947 tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc + 1, 30000, 0));
955 948
956 rtcp::SenderReport sr; 949 rtcp::SenderReport sr;
957 sr.From(kSenderSsrc); 950 sr.From(kSenderSsrc);
958 sr.Append(&tmmbr); 951 sr.Append(&tmmbr);
959 rtc::Buffer packet = sr.Build();
960 952
961 std::set<uint32_t> ssrcs; 953 SetSsrc(kMediaFlowSsrc);
962 ssrcs.insert(kMediaFlowSsrc); 954 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
963 rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs); 955 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_)).Times(0);
964 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 956 InjectPacket(sr);
965 EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); 957 EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
966 } 958 }
967 959
968 TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) { 960 TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) {
969 const uint32_t kMediaFlowSsrc = 0x2040608; 961 const uint32_t kMediaFlowSsrc = 0x2040608;
970 const uint32_t kSenderSsrc = 0x10203; 962 const uint32_t kSenderSsrc = 0x10203;
971 std::set<uint32_t> ssrcs; 963 SetSsrc(kMediaFlowSsrc);
972 ssrcs.insert(kMediaFlowSsrc); // Matches "media source" above.
973 rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs);
974 964
975 rtcp::Tmmbr tmmbr; 965 rtcp::Tmmbr tmmbr;
976 tmmbr.From(kSenderSsrc); 966 tmmbr.From(kSenderSsrc);
977 tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc, 0, 0)); 967 tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc, 0, 0));
978 968
979 rtcp::SenderReport sr; 969 rtcp::SenderReport sr;
980 sr.From(kSenderSsrc); 970 sr.From(kSenderSsrc);
981 sr.Append(&tmmbr); 971 sr.Append(&tmmbr);
982 rtc::Buffer packet = sr.Build(); 972 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
983 973 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_)).Times(0);
984 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 974 InjectPacket(sr);
985 EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); 975 EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
986 } 976 }
987 977
988 TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) { 978 TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) {
989 const uint32_t kMediaFlowSsrc = 0x2040608; 979 const uint32_t kMediaFlowSsrc = 0x2040608;
990 const uint32_t kSenderSsrc = 0x10203; 980 const uint32_t kSenderSsrc = 0x10203;
991 std::set<uint32_t> ssrcs; 981 SetSsrc(kMediaFlowSsrc);
992 ssrcs.insert(kMediaFlowSsrc); // Matches "media source" above.
993 rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs);
994 982
995 // Inject 3 packets "from" kSenderSsrc, kSenderSsrc+1, kSenderSsrc+2. 983 // Inject 3 packets "from" kSenderSsrc, kSenderSsrc+1, kSenderSsrc+2.
996 // The times of arrival are starttime + 0, starttime + 5 and starttime + 10. 984 // The times of arrival are starttime + 0, starttime + 5 and starttime + 10.
997 for (uint32_t ssrc = kSenderSsrc; ssrc < kSenderSsrc + 3; ++ssrc) { 985 for (uint32_t ssrc = kSenderSsrc; ssrc < kSenderSsrc + 3; ++ssrc) {
998 rtcp::Tmmbr tmmbr; 986 rtcp::Tmmbr tmmbr;
999 tmmbr.From(ssrc); 987 tmmbr.From(ssrc);
1000 tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc, 30000, 0)); 988 tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc, 30000, 0));
1001 989
1002 rtcp::SenderReport sr; 990 rtcp::SenderReport sr;
1003 sr.From(ssrc); 991 sr.From(ssrc);
1004 sr.Append(&tmmbr); 992 sr.Append(&tmmbr);
1005 rtc::Buffer packet = sr.Build(); 993 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
1006 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); 994 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_));
995 InjectPacket(sr);
1007 // 5 seconds between each packet. 996 // 5 seconds between each packet.
1008 system_clock_.AdvanceTimeMilliseconds(5000); 997 system_clock_.AdvanceTimeMilliseconds(5000);
1009 } 998 }
1010 // It is now starttime + 15. 999 // It is now starttime + 15.
1011 EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); 1000 EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
1012 TMMBRSet candidate_set; 1001 TMMBRSet candidate_set;
1013 candidate_set.VerifyAndAllocateSet(3); 1002 candidate_set.VerifyAndAllocateSet(3);
1014 EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set)); 1003 EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set));
1015 EXPECT_LT(0U, candidate_set.Tmmbr(0)); 1004 EXPECT_LT(0U, candidate_set.Tmmbr(0));
1016 // We expect the timeout to be 25 seconds. Advance the clock by 12 1005 // We expect the timeout to be 25 seconds. Advance the clock by 12
1017 // seconds, timing out the first packet. 1006 // seconds, timing out the first packet.
1018 system_clock_.AdvanceTimeMilliseconds(12000); 1007 system_clock_.AdvanceTimeMilliseconds(12000);
1019 // Odd behaviour: Just counting them does not trigger the timeout. 1008 // Odd behaviour: Just counting them does not trigger the timeout.
1020 EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); 1009 EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
1021 EXPECT_EQ(2, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set)); 1010 EXPECT_EQ(2, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set));
1022 EXPECT_EQ(kSenderSsrc + 1, candidate_set.Ssrc(0)); 1011 EXPECT_EQ(kSenderSsrc + 1, candidate_set.Ssrc(0));
1023 } 1012 }
1024 1013
1025 TEST_F(RtcpReceiverTest, Callbacks) { 1014 TEST_F(RtcpReceiverTest, Callbacks) {
1026 class RtcpCallbackImpl : public RtcpStatisticsCallback { 1015 MockRtcpCallbackImpl callback;
1027 public:
1028 RtcpCallbackImpl() : RtcpStatisticsCallback(), ssrc_(0) {}
1029 virtual ~RtcpCallbackImpl() {}
1030
1031 void StatisticsUpdated(const RtcpStatistics& statistics,
1032 uint32_t ssrc) override {
1033 stats_ = statistics;
1034 ssrc_ = ssrc;
1035 }
1036
1037 void CNameChanged(const char* cname, uint32_t ssrc) override {}
1038
1039 bool Matches(uint32_t ssrc, uint32_t extended_max, uint8_t fraction_loss,
1040 uint32_t cumulative_loss, uint32_t jitter) {
1041 return ssrc_ == ssrc &&
1042 stats_.fraction_lost == fraction_loss &&
1043 stats_.cumulative_lost == cumulative_loss &&
1044 stats_.extended_max_sequence_number == extended_max &&
1045 stats_.jitter == jitter;
1046 }
1047
1048 RtcpStatistics stats_;
1049 uint32_t ssrc_;
1050 } callback;
1051 1016
1052 rtcp_receiver_->RegisterRtcpStatisticsCallback(&callback); 1017 rtcp_receiver_->RegisterRtcpStatisticsCallback(&callback);
1053 1018
1054 const uint32_t kSenderSsrc = 0x10203; 1019 const uint32_t kSenderSsrc = 0x10203;
1055 const uint32_t kSourceSsrc = 0x123456; 1020 const uint32_t kSourceSsrc = 0x123456;
1056 const uint8_t kFractionLoss = 3; 1021 const uint8_t kFractionLoss = 3;
1057 const uint32_t kCumulativeLoss = 7; 1022 const uint32_t kCumulativeLoss = 7;
1058 const uint32_t kJitter = 9; 1023 const uint32_t kJitter = 9;
1059 const uint16_t kSequenceNumber = 1234; 1024 const uint16_t kSequenceNumber = 1234;
1060 1025
1061 std::set<uint32_t> ssrcs; 1026 SetSsrc(kSourceSsrc);
1062 ssrcs.insert(kSourceSsrc);
1063 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
1064 1027
1065 // First packet, all numbers should just propagate. 1028 // First packet, all numbers should just propagate.
1066 rtcp::ReportBlock rb1; 1029 rtcp::ReportBlock rb1;
1067 rb1.To(kSourceSsrc); 1030 rb1.To(kSourceSsrc);
1068 rb1.WithExtHighestSeqNum(kSequenceNumber); 1031 rb1.WithExtHighestSeqNum(kSequenceNumber);
1069 rb1.WithFractionLost(kFractionLoss); 1032 rb1.WithFractionLost(kFractionLoss);
1070 rb1.WithCumulativeLost(kCumulativeLoss); 1033 rb1.WithCumulativeLost(kCumulativeLoss);
1071 rb1.WithJitter(kJitter); 1034 rb1.WithJitter(kJitter);
1072 1035
1073 rtcp::ReceiverReport rr1; 1036 rtcp::ReceiverReport rr1;
1074 rr1.From(kSenderSsrc); 1037 rr1.From(kSenderSsrc);
1075 rr1.WithReportBlock(rb1); 1038 rr1.WithReportBlock(rb1);
1076 rtc::Buffer p1 = rr1.Build(); 1039 EXPECT_CALL(
1077 EXPECT_EQ(0, InjectRtcpPacket(p1.data(), p1.size())); 1040 callback,
1078 EXPECT_TRUE(callback.Matches(kSourceSsrc, kSequenceNumber, kFractionLoss, 1041 StatisticsUpdated(
1079 kCumulativeLoss, kJitter)); 1042 AllOf(Field(&RtcpStatistics::fraction_lost, kFractionLoss),
1043 Field(&RtcpStatistics::cumulative_lost, kCumulativeLoss),
1044 Field(&RtcpStatistics::extended_max_sequence_number,
1045 kSequenceNumber),
1046 Field(&RtcpStatistics::jitter, kJitter)),
1047 kSourceSsrc));
1048 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
1049 InjectPacket(rr1);
1080 1050
1081 rtcp_receiver_->RegisterRtcpStatisticsCallback(nullptr); 1051 rtcp_receiver_->RegisterRtcpStatisticsCallback(nullptr);
1082 1052
1083 // Add arbitrary numbers, callback should not be called (retain old values). 1053 // Add arbitrary numbers, callback should not be called.
1084 rtcp::ReportBlock rb2; 1054 rtcp::ReportBlock rb2;
1085 rb2.To(kSourceSsrc); 1055 rb2.To(kSourceSsrc);
1086 rb2.WithExtHighestSeqNum(kSequenceNumber + 1); 1056 rb2.WithExtHighestSeqNum(kSequenceNumber + 1);
1087 rb2.WithFractionLost(42); 1057 rb2.WithFractionLost(42);
1088 rb2.WithCumulativeLost(137); 1058 rb2.WithCumulativeLost(137);
1089 rb2.WithJitter(4711); 1059 rb2.WithJitter(4711);
1090 1060
1091 rtcp::ReceiverReport rr2; 1061 rtcp::ReceiverReport rr2;
1092 rr2.From(kSenderSsrc); 1062 rr2.From(kSenderSsrc);
1093 rr2.WithReportBlock(rb2); 1063 rr2.WithReportBlock(rb2);
1094 rtc::Buffer p2 = rr2.Build(); 1064 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
1095 EXPECT_EQ(0, InjectRtcpPacket(p2.data(), p2.size())); 1065 EXPECT_CALL(callback, StatisticsUpdated(_, _)).Times(0);
1096 EXPECT_TRUE(callback.Matches(kSourceSsrc, kSequenceNumber, kFractionLoss, 1066 InjectPacket(rr2);
1097 kCumulativeLoss, kJitter));
1098 } 1067 }
1099 1068
1100 TEST_F(RtcpReceiverTest, ReceivesTransportFeedback) { 1069 TEST_F(RtcpReceiverTest, ReceivesTransportFeedback) {
1070 using rtcp::TransportFeedback;
1101 const uint32_t kSenderSsrc = 0x10203; 1071 const uint32_t kSenderSsrc = 0x10203;
1102 const uint32_t kSourceSsrc = 0x123456; 1072 const uint32_t kSourceSsrc = 0x123456;
1103 1073
1104 std::set<uint32_t> ssrcs; 1074 SetSsrc(kSourceSsrc);
1105 ssrcs.insert(kSourceSsrc);
1106 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
1107 1075
1108 rtcp::TransportFeedback packet; 1076 TransportFeedback packet;
1109 packet.WithMediaSourceSsrc(kSourceSsrc); 1077 packet.WithMediaSourceSsrc(kSourceSsrc);
1110 packet.WithPacketSenderSsrc(kSenderSsrc); 1078 packet.WithPacketSenderSsrc(kSenderSsrc);
1111 packet.WithBase(1, 1000); 1079 packet.WithBase(1, 1000);
1112 packet.WithReceivedPacket(1, 1000); 1080 packet.WithReceivedPacket(1, 1000);
1113 1081
1114 rtc::Buffer built_packet = packet.Build(); 1082 EXPECT_CALL(
1115 1083 transport_feedback_observer_,
1116 EXPECT_EQ(0, InjectRtcpPacket(built_packet.data(), built_packet.size())); 1084 OnTransportFeedback(AllOf(
1117 1085 Property(&TransportFeedback::GetMediaSourceSsrc, kSourceSsrc),
1118 EXPECT_NE(0u, rtcp_packet_info_.rtcpPacketTypeFlags & kRtcpTransportFeedback); 1086 Property(&TransportFeedback::GetPacketSenderSsrc, kSenderSsrc))));
1119 EXPECT_TRUE(rtcp_packet_info_.transport_feedback_.get() != nullptr); 1087 InjectPacket(packet);
1120 } 1088 }
1121 1089
1122 TEST_F(RtcpReceiverTest, HandlesInvalidTransportFeedback) { 1090 TEST_F(RtcpReceiverTest, HandlesInvalidTransportFeedback) {
1123 const uint32_t kSenderSsrc = 0x10203; 1091 const uint32_t kSenderSsrc = 0x10203;
1124 const uint32_t kSourceSsrc = 0x123456; 1092 const uint32_t kSourceSsrc = 0x123456;
1125 1093
1126 std::set<uint32_t> ssrcs; 1094 SetSsrc(kSourceSsrc);
1127 ssrcs.insert(kSourceSsrc);
1128 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
1129 1095
1130 // Send a compound packet with a TransportFeedback followed by something else. 1096 // Send a compound packet with a TransportFeedback followed by something else.
1131 rtcp::TransportFeedback packet; 1097 rtcp::TransportFeedback packet;
1132 packet.WithMediaSourceSsrc(kSourceSsrc); 1098 packet.WithMediaSourceSsrc(kSourceSsrc);
1133 packet.WithPacketSenderSsrc(kSenderSsrc); 1099 packet.WithPacketSenderSsrc(kSenderSsrc);
1134 packet.WithBase(1, 1000); 1100 packet.WithBase(1, 1000);
1135 packet.WithReceivedPacket(1, 1000); 1101 packet.WithReceivedPacket(1, 1000);
1136 1102
1137 static uint32_t kBitrateBps = 50000; 1103 static uint32_t kBitrateBps = 50000;
1138 rtcp::Remb remb; 1104 rtcp::Remb remb;
1139 remb.From(kSourceSsrc); 1105 remb.From(kSourceSsrc);
1140 remb.WithBitrateBps(kBitrateBps); 1106 remb.WithBitrateBps(kBitrateBps);
1141 packet.Append(&remb); 1107 packet.Append(&remb);
1142 1108
1143 rtc::Buffer built_packet = packet.Build(); 1109 rtc::Buffer built_packet = packet.Build();
1144 1110
1145 // Modify the TransportFeedback packet so that it is invalid. 1111 // Modify the TransportFeedback packet so that it is invalid.
1146 const size_t kStatusCountOffset = 14; 1112 const size_t kStatusCountOffset = 14;
1147 ByteWriter<uint16_t>::WriteBigEndian( 1113 ByteWriter<uint16_t>::WriteBigEndian(
1148 &built_packet.data()[kStatusCountOffset], 42); 1114 &built_packet.data()[kStatusCountOffset], 42);
1149 1115
1150 EXPECT_EQ(0, InjectRtcpPacket(built_packet.data(), built_packet.size())); 1116 // Explicetly repeat that no tansport feedback callback is expected.
1151 1117 EXPECT_CALL(transport_feedback_observer_, OnTransportFeedback(_)).Times(0);
1152 // Transport feedback should be ignored, but next packet should work. 1118 // But remb should be processed and cause a callback
1153 EXPECT_EQ(0u, rtcp_packet_info_.rtcpPacketTypeFlags & kRtcpTransportFeedback); 1119 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps));
1154 EXPECT_NE(0u, rtcp_packet_info_.rtcpPacketTypeFlags & kRtcpRemb); 1120 EXPECT_TRUE(rtcp_receiver_->IncomingPacket(built_packet.data(),
1155 EXPECT_EQ(kBitrateBps, rtcp_packet_info_.receiverEstimatedMaxBitrate); 1121 built_packet.size()));
1156 } 1122 }
1157 1123
1158 } // Anonymous namespace 1124 TEST_F(RtcpReceiverTest, Nack) {
1125 const uint32_t kSenderSsrc = 0x10203;
1126 const uint32_t kSourceSsrc = 0x123456;
1127 const uint16_t kNackList1[] = {1, 2, 3, 5};
1128 const size_t kNackListLength1 = std::end(kNackList1) - std::begin(kNackList1);
1129 const uint16_t kNackList2[] = {5, 7, 30, 40};
1130 const size_t kNackListLength2 = std::end(kNackList2) - std::begin(kNackList2);
1131 SetSsrc(kSourceSsrc);
1159 1132
1133 rtcp::Nack nack;
1134 nack.From(kSenderSsrc);
1135 nack.To(kSourceSsrc);
1136 nack.WithList(kNackList1, kNackListLength1);
1137
1138 EXPECT_CALL(
1139 packet_type_counter_observer_,
1140 RtcpPacketTypesCounterUpdated(
1141 kSourceSsrc,
1142 AllOf(Field(&RtcpPacketTypeCounter::nack_requests, 4),
1143 Field(&RtcpPacketTypeCounter::unique_nack_requests, 4))));
1144 InjectPacket(nack);
1145
1146 rtcp::Nack nack2;
1147 nack2.From(kSenderSsrc);
1148 nack2.To(kSourceSsrc);
1149 nack2.WithList(kNackList2, kNackListLength2);
1150 EXPECT_CALL(
1151 packet_type_counter_observer_,
1152 RtcpPacketTypesCounterUpdated(
1153 kSourceSsrc,
1154 AllOf(Field(&RtcpPacketTypeCounter::nack_requests, 8),
1155 Field(&RtcpPacketTypeCounter::unique_nack_requests, 7))));
1156 InjectPacket(nack2);
1157 }
1158
1159 TEST_F(RtcpReceiverTest, NackNotForUsIgnored) {
1160 const uint32_t kSenderSsrc = 0x10203;
1161 const uint32_t kSourceSsrc = 0x123456;
1162 const uint16_t kNackList1[] = {1, 2, 3, 5};
1163 const size_t kNackListLength1 = std::end(kNackList1) - std::begin(kNackList1);
1164 SetSsrc(kSourceSsrc);
1165
1166 rtcp::Nack nack;
1167 nack.From(kSenderSsrc);
1168 nack.To(kSourceSsrc + 1);
1169 nack.WithList(kNackList1, kNackListLength1);
1170
1171 EXPECT_CALL(packet_type_counter_observer_,
1172 RtcpPacketTypesCounterUpdated(
1173 _, Field(&RtcpPacketTypeCounter::nack_requests, 0)));
1174 InjectPacket(nack);
1175 }
1176 // TODO(danilchap): Add test for SendReportRequest experemental packet.
1160 } // namespace webrtc 1177 } // namespace webrtc
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698