OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/memory/scoped_ptr.h" | 5 #include "base/memory/scoped_ptr.h" |
6 #include "base/test/simple_test_tick_clock.h" | 6 #include "base/test/simple_test_tick_clock.h" |
7 #include "media/cast/cast_environment.h" | 7 #include "media/cast/cast_environment.h" |
8 #include "media/cast/net/cast_transport_defines.h" | 8 #include "media/cast/net/cast_transport_defines.h" |
9 #include "media/cast/net/rtcp/mock_rtcp_receiver_feedback.h" | 9 #include "media/cast/net/rtcp/mock_rtcp_receiver_feedback.h" |
10 #include "media/cast/net/rtcp/mock_rtcp_sender_feedback.h" | |
11 #include "media/cast/net/rtcp/rtcp_receiver.h" | 10 #include "media/cast/net/rtcp/rtcp_receiver.h" |
12 #include "media/cast/net/rtcp/rtcp_utility.h" | 11 #include "media/cast/net/rtcp/rtcp_utility.h" |
13 #include "media/cast/net/rtcp/test_rtcp_packet_builder.h" | 12 #include "media/cast/net/rtcp/test_rtcp_packet_builder.h" |
14 #include "media/cast/test/fake_single_thread_task_runner.h" | 13 #include "media/cast/test/fake_single_thread_task_runner.h" |
15 #include "testing/gmock/include/gmock/gmock.h" | 14 #include "testing/gmock/include/gmock/gmock.h" |
16 | 15 |
17 namespace media { | 16 namespace media { |
18 namespace cast { | 17 namespace cast { |
19 | 18 |
20 using testing::_; | 19 using testing::_; |
21 | 20 |
22 static const uint32 kSenderSsrc = 0x10203; | 21 static const uint32 kSenderSsrc = 0x10203; |
23 static const uint32 kSourceSsrc = 0x40506; | 22 static const uint32 kSourceSsrc = 0x40506; |
24 static const uint32 kUnknownSsrc = 0xDEAD; | 23 static const uint32 kUnknownSsrc = 0xDEAD; |
25 static const base::TimeDelta kTargetDelay = | 24 static const base::TimeDelta kTargetDelay = |
26 base::TimeDelta::FromMilliseconds(100); | 25 base::TimeDelta::FromMilliseconds(100); |
27 static const std::string kCName("test@10.1.1.1"); | 26 static const std::string kCName("test@10.1.1.1"); |
28 | 27 |
29 namespace { | 28 namespace { |
30 class SenderFeedbackCastVerification : public RtcpSenderFeedback { | 29 |
| 30 class RtcpMessageVerification : public MockRtcpReceiverFeedback { |
31 public: | 31 public: |
32 SenderFeedbackCastVerification() : called_(false) {} | 32 RtcpMessageVerification() |
33 | |
34 virtual void OnReceivedCastFeedback(const RtcpCastMessage& cast_feedback) | |
35 OVERRIDE { | |
36 EXPECT_EQ(cast_feedback.media_ssrc_, kSenderSsrc); | |
37 EXPECT_EQ(cast_feedback.ack_frame_id_, kAckFrameId); | |
38 | |
39 MissingFramesAndPacketsMap::const_iterator frame_it = | |
40 cast_feedback.missing_frames_and_packets_.begin(); | |
41 | |
42 EXPECT_TRUE(frame_it != cast_feedback.missing_frames_and_packets_.end()); | |
43 EXPECT_EQ(kLostFrameId, frame_it->first); | |
44 EXPECT_EQ(frame_it->second.size(), 1UL); | |
45 EXPECT_EQ(*frame_it->second.begin(), kRtcpCastAllPacketsLost); | |
46 ++frame_it; | |
47 EXPECT_TRUE(frame_it != cast_feedback.missing_frames_and_packets_.end()); | |
48 EXPECT_EQ(kFrameIdWithLostPackets, frame_it->first); | |
49 EXPECT_EQ(3UL, frame_it->second.size()); | |
50 PacketIdSet::const_iterator packet_it = frame_it->second.begin(); | |
51 EXPECT_EQ(kLostPacketId1, *packet_it); | |
52 ++packet_it; | |
53 EXPECT_EQ(kLostPacketId2, *packet_it); | |
54 ++packet_it; | |
55 EXPECT_EQ(kLostPacketId3, *packet_it); | |
56 ++frame_it; | |
57 EXPECT_EQ(frame_it, cast_feedback.missing_frames_and_packets_.end()); | |
58 called_ = true; | |
59 } | |
60 | |
61 bool called() const { return called_; } | |
62 | |
63 private: | |
64 bool called_; | |
65 | |
66 DISALLOW_COPY_AND_ASSIGN(SenderFeedbackCastVerification); | |
67 }; | |
68 | |
69 class RtcpReceiverCastLogVerification : public RtcpReceiverFeedback { | |
70 public: | |
71 RtcpReceiverCastLogVerification() | |
72 : called_on_received_sender_log_(false), | 33 : called_on_received_sender_log_(false), |
73 called_on_received_receiver_log_(false) {} | 34 called_on_received_receiver_log_(false), |
74 | 35 called_on_received_cast_message_(false) {} |
75 virtual void OnReceivedSenderReport( | |
76 const RtcpSenderInfo& remote_sender_info) OVERRIDE{}; | |
77 | |
78 virtual void OnReceiverReferenceTimeReport( | |
79 const RtcpReceiverReferenceTimeReport& remote_time_report) OVERRIDE{}; | |
80 | |
81 virtual void OnReceivedSendReportRequest() OVERRIDE{}; | |
82 | 36 |
83 virtual void OnReceivedReceiverLog(const RtcpReceiverLogMessage& receiver_log) | 37 virtual void OnReceivedReceiverLog(const RtcpReceiverLogMessage& receiver_log) |
84 OVERRIDE { | 38 OVERRIDE { |
85 EXPECT_EQ(expected_receiver_log_.size(), receiver_log.size()); | 39 EXPECT_EQ(expected_receiver_log_.size(), receiver_log.size()); |
86 RtcpReceiverLogMessage::const_iterator expected_it = | 40 RtcpReceiverLogMessage::const_iterator expected_it = |
87 expected_receiver_log_.begin(); | 41 expected_receiver_log_.begin(); |
88 RtcpReceiverLogMessage::const_iterator incoming_it = receiver_log.begin(); | 42 RtcpReceiverLogMessage::const_iterator incoming_it = receiver_log.begin(); |
89 for (; incoming_it != receiver_log.end(); ++incoming_it) { | 43 for (; incoming_it != receiver_log.end(); ++incoming_it) { |
90 EXPECT_EQ(expected_it->rtp_timestamp_, incoming_it->rtp_timestamp_); | 44 EXPECT_EQ(expected_it->rtp_timestamp_, incoming_it->rtp_timestamp_); |
91 EXPECT_EQ(expected_it->event_log_messages_.size(), | 45 EXPECT_EQ(expected_it->event_log_messages_.size(), |
(...skipping 14 matching lines...) Expand all Loading... |
106 EXPECT_EQ(event_expected_it->delay_delta, | 60 EXPECT_EQ(event_expected_it->delay_delta, |
107 event_incoming_it->delay_delta); | 61 event_incoming_it->delay_delta); |
108 } | 62 } |
109 } | 63 } |
110 expected_receiver_log_.pop_front(); | 64 expected_receiver_log_.pop_front(); |
111 expected_it = expected_receiver_log_.begin(); | 65 expected_it = expected_receiver_log_.begin(); |
112 } | 66 } |
113 called_on_received_receiver_log_ = true; | 67 called_on_received_receiver_log_ = true; |
114 } | 68 } |
115 | 69 |
116 bool OnReceivedReceiverLogCalled() { | 70 virtual void OnReceivedCastFeedback(const RtcpCastMessage& cast_message) |
| 71 OVERRIDE { |
| 72 EXPECT_EQ(cast_message.media_ssrc, kSenderSsrc); |
| 73 EXPECT_EQ(cast_message.ack_frame_id, kAckFrameId); |
| 74 |
| 75 MissingFramesAndPacketsMap::const_iterator frame_it = |
| 76 cast_message.missing_frames_and_packets.begin(); |
| 77 |
| 78 EXPECT_TRUE(frame_it != cast_message.missing_frames_and_packets.end()); |
| 79 EXPECT_EQ(kLostFrameId, frame_it->first); |
| 80 EXPECT_EQ(frame_it->second.size(), 1UL); |
| 81 EXPECT_EQ(*frame_it->second.begin(), kRtcpCastAllPacketsLost); |
| 82 ++frame_it; |
| 83 EXPECT_TRUE(frame_it != cast_message.missing_frames_and_packets.end()); |
| 84 EXPECT_EQ(kFrameIdWithLostPackets, frame_it->first); |
| 85 EXPECT_EQ(3UL, frame_it->second.size()); |
| 86 PacketIdSet::const_iterator packet_it = frame_it->second.begin(); |
| 87 EXPECT_EQ(kLostPacketId1, *packet_it); |
| 88 ++packet_it; |
| 89 EXPECT_EQ(kLostPacketId2, *packet_it); |
| 90 ++packet_it; |
| 91 EXPECT_EQ(kLostPacketId3, *packet_it); |
| 92 ++frame_it; |
| 93 EXPECT_EQ(frame_it, cast_message.missing_frames_and_packets.end()); |
| 94 called_on_received_cast_message_ = true; |
| 95 } |
| 96 |
| 97 bool OnReceivedReceiverLogCalled() const { |
117 return called_on_received_receiver_log_ && expected_receiver_log_.empty(); | 98 return called_on_received_receiver_log_ && expected_receiver_log_.empty(); |
118 } | 99 } |
119 | 100 |
| 101 bool OnReceivedCastFeedbackCalled() const { |
| 102 return called_on_received_cast_message_; |
| 103 } |
| 104 |
120 void SetExpectedReceiverLog(const RtcpReceiverLogMessage& receiver_log) { | 105 void SetExpectedReceiverLog(const RtcpReceiverLogMessage& receiver_log) { |
121 expected_receiver_log_ = receiver_log; | 106 expected_receiver_log_ = receiver_log; |
122 } | 107 } |
123 | 108 |
124 private: | 109 private: |
125 RtcpReceiverLogMessage expected_receiver_log_; | 110 RtcpReceiverLogMessage expected_receiver_log_; |
126 bool called_on_received_sender_log_; | 111 bool called_on_received_sender_log_; |
127 bool called_on_received_receiver_log_; | 112 bool called_on_received_receiver_log_; |
| 113 bool called_on_received_cast_message_; |
128 | 114 |
129 DISALLOW_COPY_AND_ASSIGN(RtcpReceiverCastLogVerification); | 115 DISALLOW_COPY_AND_ASSIGN(RtcpMessageVerification); |
130 }; | 116 }; |
131 | 117 |
132 } // namespace | 118 } // namespace |
133 | 119 |
134 class RtcpReceiverTest : public ::testing::Test { | 120 class RtcpReceiverTest : public ::testing::Test { |
135 protected: | 121 protected: |
136 RtcpReceiverTest() | 122 RtcpReceiverTest() |
137 : testing_clock_(new base::SimpleTestTickClock()), | 123 : testing_clock_(new base::SimpleTestTickClock()), |
138 task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)), | 124 task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)), |
139 cast_environment_(new CastEnvironment( | 125 rtcp_receiver_(new RtcpReceiver(&mock_receiver_feedback_, |
140 scoped_ptr<base::TickClock>(testing_clock_).Pass(), | |
141 task_runner_, | |
142 task_runner_, | |
143 task_runner_)), | |
144 rtcp_receiver_(new RtcpReceiver(cast_environment_, | |
145 &mock_sender_feedback_, | |
146 &mock_receiver_feedback_, | |
147 &mock_rtt_feedback_, | |
148 kSourceSsrc)) { | 126 kSourceSsrc)) { |
149 EXPECT_CALL(mock_receiver_feedback_, OnReceivedSenderReport(_)).Times(0); | 127 EXPECT_CALL(mock_receiver_feedback_, OnReceivedSenderReport(_)).Times(0); |
150 EXPECT_CALL(mock_receiver_feedback_, OnReceiverReferenceTimeReport(_)) | 128 EXPECT_CALL(mock_receiver_feedback_, OnReceiverReferenceTimeReport(_)) |
151 .Times(0); | 129 .Times(0); |
152 EXPECT_CALL(mock_receiver_feedback_, OnReceivedSendReportRequest()) | 130 EXPECT_CALL(mock_receiver_feedback_, OnReceivedCastFeedback(_)).Times(0); |
153 .Times(0); | 131 EXPECT_CALL(mock_receiver_feedback_, OnReceivedDelaySinceLastReport(_, _)) |
154 EXPECT_CALL(mock_sender_feedback_, OnReceivedCastFeedback(_)).Times(0); | |
155 EXPECT_CALL(mock_rtt_feedback_, OnReceivedDelaySinceLastReport(_, _, _)) | |
156 .Times(0); | 132 .Times(0); |
157 | 133 |
158 expected_sender_info_.ntp_seconds = kNtpHigh; | 134 expected_sender_info_.ntp_seconds = kNtpHigh; |
159 expected_sender_info_.ntp_fraction = kNtpLow; | 135 expected_sender_info_.ntp_fraction = kNtpLow; |
160 expected_sender_info_.rtp_timestamp = kRtpTimestamp; | 136 expected_sender_info_.rtp_timestamp = kRtpTimestamp; |
161 expected_sender_info_.send_packet_count = kSendPacketCount; | 137 expected_sender_info_.send_packet_count = kSendPacketCount; |
162 expected_sender_info_.send_octet_count = kSendOctetCount; | 138 expected_sender_info_.send_octet_count = kSendOctetCount; |
163 | 139 |
164 expected_report_block_.remote_ssrc = kSenderSsrc; | 140 expected_report_block_.remote_ssrc = kSenderSsrc; |
165 expected_report_block_.media_ssrc = kSourceSsrc; | 141 expected_report_block_.media_ssrc = kSourceSsrc; |
(...skipping 11 matching lines...) Expand all Loading... |
177 virtual ~RtcpReceiverTest() {} | 153 virtual ~RtcpReceiverTest() {} |
178 | 154 |
179 // Injects an RTCP packet into the receiver. | 155 // Injects an RTCP packet into the receiver. |
180 void InjectRtcpPacket(const uint8* packet, uint16 length) { | 156 void InjectRtcpPacket(const uint8* packet, uint16 length) { |
181 RtcpParser rtcp_parser(packet, length); | 157 RtcpParser rtcp_parser(packet, length); |
182 rtcp_receiver_->IncomingRtcpPacket(&rtcp_parser); | 158 rtcp_receiver_->IncomingRtcpPacket(&rtcp_parser); |
183 } | 159 } |
184 | 160 |
185 base::SimpleTestTickClock* testing_clock_; // Owned by CastEnvironment. | 161 base::SimpleTestTickClock* testing_clock_; // Owned by CastEnvironment. |
186 scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_; | 162 scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_; |
187 scoped_refptr<CastEnvironment> cast_environment_; | |
188 MockRtcpReceiverFeedback mock_receiver_feedback_; | 163 MockRtcpReceiverFeedback mock_receiver_feedback_; |
189 MockRtcpRttFeedback mock_rtt_feedback_; | |
190 MockRtcpSenderFeedback mock_sender_feedback_; | |
191 scoped_ptr<RtcpReceiver> rtcp_receiver_; | 164 scoped_ptr<RtcpReceiver> rtcp_receiver_; |
192 RtcpSenderInfo expected_sender_info_; | 165 RtcpSenderInfo expected_sender_info_; |
193 RtcpReportBlock expected_report_block_; | 166 RtcpReportBlock expected_report_block_; |
194 RtcpReceiverReferenceTimeReport expected_receiver_reference_report_; | 167 RtcpReceiverReferenceTimeReport expected_receiver_reference_report_; |
195 | 168 |
196 DISALLOW_COPY_AND_ASSIGN(RtcpReceiverTest); | 169 DISALLOW_COPY_AND_ASSIGN(RtcpReceiverTest); |
197 }; | 170 }; |
198 | 171 |
199 TEST_F(RtcpReceiverTest, BrokenPacketIsIgnored) { | 172 TEST_F(RtcpReceiverTest, BrokenPacketIsIgnored) { |
200 const uint8 bad_packet[] = {0, 0, 0, 0}; | 173 const uint8 bad_packet[] = {0, 0, 0, 0}; |
(...skipping 18 matching lines...) Expand all Loading... |
219 | 192 |
220 TEST_F(RtcpReceiverTest, InjectReceiveReportPacket) { | 193 TEST_F(RtcpReceiverTest, InjectReceiveReportPacket) { |
221 TestRtcpPacketBuilder p1; | 194 TestRtcpPacketBuilder p1; |
222 p1.AddRr(kSenderSsrc, 1); | 195 p1.AddRr(kSenderSsrc, 1); |
223 p1.AddRb(kUnknownSsrc); | 196 p1.AddRb(kUnknownSsrc); |
224 | 197 |
225 // Expected to be ignored since the source ssrc does not match our | 198 // Expected to be ignored since the source ssrc does not match our |
226 // local ssrc. | 199 // local ssrc. |
227 InjectRtcpPacket(p1.Data(), p1.Length()); | 200 InjectRtcpPacket(p1.Data(), p1.Length()); |
228 | 201 |
229 EXPECT_CALL(mock_rtt_feedback_, | 202 EXPECT_CALL(mock_receiver_feedback_, |
230 OnReceivedDelaySinceLastReport( | 203 OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1); |
231 kSourceSsrc, kLastSr, kDelayLastSr)).Times(1); | |
232 | 204 |
233 TestRtcpPacketBuilder p2; | 205 TestRtcpPacketBuilder p2; |
234 p2.AddRr(kSenderSsrc, 1); | 206 p2.AddRr(kSenderSsrc, 1); |
235 p2.AddRb(kSourceSsrc); | 207 p2.AddRb(kSourceSsrc); |
236 | 208 |
237 // Expected to be pass through since the sender ssrc match our local ssrc. | 209 // Expected to be pass through since the sender ssrc match our local ssrc. |
238 InjectRtcpPacket(p2.Data(), p2.Length()); | 210 InjectRtcpPacket(p2.Data(), p2.Length()); |
239 } | 211 } |
240 | 212 |
241 TEST_F(RtcpReceiverTest, InjectSenderReportWithReportBlockPacket) { | 213 TEST_F(RtcpReceiverTest, InjectSenderReportWithReportBlockPacket) { |
(...skipping 11 matching lines...) Expand all Loading... |
253 OnReceivedSenderReport(expected_sender_info_)).Times(1); | 225 OnReceivedSenderReport(expected_sender_info_)).Times(1); |
254 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); | 226 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); |
255 | 227 |
256 // Sender report expected to be pass through since the sender ssrc match our | 228 // Sender report expected to be pass through since the sender ssrc match our |
257 // remote ssrc. | 229 // remote ssrc. |
258 // Report block expected to be ignored since the source ssrc does not match | 230 // Report block expected to be ignored since the source ssrc does not match |
259 // our local ssrc. | 231 // our local ssrc. |
260 InjectRtcpPacket(p1.Data(), p1.Length()); | 232 InjectRtcpPacket(p1.Data(), p1.Length()); |
261 | 233 |
262 EXPECT_CALL(mock_receiver_feedback_, OnReceivedSenderReport(_)).Times(0); | 234 EXPECT_CALL(mock_receiver_feedback_, OnReceivedSenderReport(_)).Times(0); |
263 EXPECT_CALL(mock_rtt_feedback_, | 235 EXPECT_CALL(mock_receiver_feedback_, |
264 OnReceivedDelaySinceLastReport( | 236 OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1); |
265 kSourceSsrc, kLastSr, kDelayLastSr)).Times(1); | |
266 | 237 |
267 rtcp_receiver_->SetRemoteSSRC(0); | 238 rtcp_receiver_->SetRemoteSSRC(0); |
268 | 239 |
269 TestRtcpPacketBuilder p2; | 240 TestRtcpPacketBuilder p2; |
270 p2.AddSr(kSenderSsrc, 1); | 241 p2.AddSr(kSenderSsrc, 1); |
271 p2.AddRb(kSourceSsrc); | 242 p2.AddRb(kSourceSsrc); |
272 | 243 |
273 // Sender report expected to be ignored since the sender ssrc does not match | 244 // Sender report expected to be ignored since the sender ssrc does not match |
274 // our remote ssrc. | 245 // our remote ssrc. |
275 // Receiver report expected to be pass through since the sender ssrc match | 246 // Receiver report expected to be pass through since the sender ssrc match |
276 // our local ssrc. | 247 // our local ssrc. |
277 InjectRtcpPacket(p2.Data(), p2.Length()); | 248 InjectRtcpPacket(p2.Data(), p2.Length()); |
278 | 249 |
279 EXPECT_CALL(mock_receiver_feedback_, | 250 EXPECT_CALL(mock_receiver_feedback_, |
280 OnReceivedSenderReport(expected_sender_info_)).Times(1); | 251 OnReceivedSenderReport(expected_sender_info_)).Times(1); |
281 EXPECT_CALL(mock_rtt_feedback_, | 252 EXPECT_CALL(mock_receiver_feedback_, |
282 OnReceivedDelaySinceLastReport( | 253 OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1); |
283 kSourceSsrc, kLastSr, kDelayLastSr)).Times(1); | |
284 | 254 |
285 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); | 255 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); |
286 | 256 |
287 // Sender report expected to be pass through since the sender ssrc match our | 257 // Sender report expected to be pass through since the sender ssrc match our |
288 // remote ssrc. | 258 // remote ssrc. |
289 // Receiver report expected to be pass through since the sender ssrc match | 259 // Receiver report expected to be pass through since the sender ssrc match |
290 // our local ssrc. | 260 // our local ssrc. |
291 InjectRtcpPacket(p2.Data(), p2.Length()); | 261 InjectRtcpPacket(p2.Data(), p2.Length()); |
292 } | 262 } |
293 | 263 |
294 TEST_F(RtcpReceiverTest, InjectSenderReportPacketWithDlrr) { | 264 TEST_F(RtcpReceiverTest, InjectSenderReportPacketWithDlrr) { |
295 TestRtcpPacketBuilder p; | 265 TestRtcpPacketBuilder p; |
296 p.AddSr(kSenderSsrc, 0); | 266 p.AddSr(kSenderSsrc, 0); |
297 p.AddXrHeader(kSenderSsrc); | 267 p.AddXrHeader(kSenderSsrc); |
298 p.AddXrUnknownBlock(); | 268 p.AddXrUnknownBlock(); |
299 p.AddXrExtendedDlrrBlock(kSenderSsrc); | 269 p.AddXrExtendedDlrrBlock(kSenderSsrc); |
300 p.AddXrUnknownBlock(); | 270 p.AddXrUnknownBlock(); |
301 p.AddSdesCname(kSenderSsrc, kCName); | 271 p.AddSdesCname(kSenderSsrc, kCName); |
302 | 272 |
303 // Expected to be ignored since the source ssrc does not match our | 273 // Expected to be ignored since the source ssrc does not match our |
304 // local ssrc. | 274 // local ssrc. |
305 InjectRtcpPacket(p.Data(), p.Length()); | 275 InjectRtcpPacket(p.Data(), p.Length()); |
306 | 276 |
307 EXPECT_CALL(mock_receiver_feedback_, | 277 EXPECT_CALL(mock_receiver_feedback_, |
308 OnReceivedSenderReport(expected_sender_info_)).Times(1); | 278 OnReceivedSenderReport(expected_sender_info_)).Times(1); |
309 EXPECT_CALL(mock_rtt_feedback_, | 279 EXPECT_CALL(mock_receiver_feedback_, |
310 OnReceivedDelaySinceLastReport( | 280 OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1); |
311 kSenderSsrc, kLastSr, kDelayLastSr)).Times(1); | |
312 | 281 |
313 // Enable receiving sender report. | 282 // Enable receiving sender report. |
314 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); | 283 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); |
315 | 284 |
316 // Expected to be pass through since the sender ssrc match our local ssrc. | 285 // Expected to be pass through since the sender ssrc match our local ssrc. |
317 InjectRtcpPacket(p.Data(), p.Length()); | 286 InjectRtcpPacket(p.Data(), p.Length()); |
318 } | 287 } |
319 | 288 |
320 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithRrtr) { | 289 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithRrtr) { |
321 TestRtcpPacketBuilder p1; | 290 TestRtcpPacketBuilder p1; |
322 p1.AddRr(kSenderSsrc, 1); | 291 p1.AddRr(kSenderSsrc, 1); |
323 p1.AddRb(kUnknownSsrc); | 292 p1.AddRb(kUnknownSsrc); |
324 p1.AddXrHeader(kSenderSsrc); | 293 p1.AddXrHeader(kSenderSsrc); |
325 p1.AddXrRrtrBlock(); | 294 p1.AddXrRrtrBlock(); |
326 | 295 |
327 // Expected to be ignored since the source ssrc does not match our | 296 // Expected to be ignored since the source ssrc does not match our |
328 // local ssrc. | 297 // local ssrc. |
329 InjectRtcpPacket(p1.Data(), p1.Length()); | 298 InjectRtcpPacket(p1.Data(), p1.Length()); |
330 | 299 |
331 EXPECT_CALL(mock_rtt_feedback_, | 300 EXPECT_CALL(mock_receiver_feedback_, |
332 OnReceivedDelaySinceLastReport( | 301 OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1); |
333 kSourceSsrc, kLastSr, kDelayLastSr)).Times(1); | |
334 EXPECT_CALL(mock_receiver_feedback_, | 302 EXPECT_CALL(mock_receiver_feedback_, |
335 OnReceiverReferenceTimeReport( | 303 OnReceiverReferenceTimeReport( |
336 expected_receiver_reference_report_)).Times(1); | 304 expected_receiver_reference_report_)).Times(1); |
337 | 305 |
338 // Enable receiving reference time report. | 306 // Enable receiving reference time report. |
339 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); | 307 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); |
340 | 308 |
341 TestRtcpPacketBuilder p2; | 309 TestRtcpPacketBuilder p2; |
342 p2.AddRr(kSenderSsrc, 1); | 310 p2.AddRr(kSenderSsrc, 1); |
343 p2.AddRb(kSourceSsrc); | 311 p2.AddRb(kSourceSsrc); |
344 p2.AddXrHeader(kSenderSsrc); | 312 p2.AddXrHeader(kSenderSsrc); |
345 p2.AddXrRrtrBlock(); | 313 p2.AddXrRrtrBlock(); |
346 | 314 |
347 // Expected to be pass through since the sender ssrc match our local ssrc. | 315 // Expected to be pass through since the sender ssrc match our local ssrc. |
348 InjectRtcpPacket(p2.Data(), p2.Length()); | 316 InjectRtcpPacket(p2.Data(), p2.Length()); |
349 } | 317 } |
350 | 318 |
351 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithIntraFrameRequest) { | 319 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithIntraFrameRequest) { |
352 TestRtcpPacketBuilder p1; | 320 TestRtcpPacketBuilder p1; |
353 p1.AddRr(kSenderSsrc, 1); | 321 p1.AddRr(kSenderSsrc, 1); |
354 p1.AddRb(kUnknownSsrc); | 322 p1.AddRb(kUnknownSsrc); |
355 p1.AddPli(kSenderSsrc, kUnknownSsrc); | 323 p1.AddPli(kSenderSsrc, kUnknownSsrc); |
356 | 324 |
357 // Expected to be ignored since the source ssrc does not match our | 325 // Expected to be ignored since the source ssrc does not match our |
358 // local ssrc. | 326 // local ssrc. |
359 InjectRtcpPacket(p1.Data(), p1.Length()); | 327 InjectRtcpPacket(p1.Data(), p1.Length()); |
360 | 328 |
361 EXPECT_CALL(mock_rtt_feedback_, | 329 EXPECT_CALL(mock_receiver_feedback_, |
362 OnReceivedDelaySinceLastReport( | 330 OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1); |
363 kSourceSsrc, kLastSr, kDelayLastSr)).Times(1); | |
364 | 331 |
365 TestRtcpPacketBuilder p2; | 332 TestRtcpPacketBuilder p2; |
366 p2.AddRr(kSenderSsrc, 1); | 333 p2.AddRr(kSenderSsrc, 1); |
367 p2.AddRb(kSourceSsrc); | 334 p2.AddRb(kSourceSsrc); |
368 p2.AddPli(kSenderSsrc, kSourceSsrc); | 335 p2.AddPli(kSenderSsrc, kSourceSsrc); |
369 | 336 |
370 // Expected to be pass through since the sender ssrc match our local ssrc. | 337 // Expected to be pass through since the sender ssrc match our local ssrc. |
371 InjectRtcpPacket(p2.Data(), p2.Length()); | 338 InjectRtcpPacket(p2.Data(), p2.Length()); |
372 } | 339 } |
373 | 340 |
374 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithCastFeedback) { | 341 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithCastFeedback) { |
375 TestRtcpPacketBuilder p1; | 342 TestRtcpPacketBuilder p1; |
376 p1.AddRr(kSenderSsrc, 1); | 343 p1.AddRr(kSenderSsrc, 1); |
377 p1.AddRb(kUnknownSsrc); | 344 p1.AddRb(kUnknownSsrc); |
378 p1.AddCast(kSenderSsrc, kUnknownSsrc, kTargetDelay); | 345 p1.AddCast(kSenderSsrc, kUnknownSsrc, kTargetDelay); |
379 | 346 |
380 // Expected to be ignored since the source ssrc does not match our | 347 // Expected to be ignored since the source ssrc does not match our |
381 // local ssrc. | 348 // local ssrc. |
382 InjectRtcpPacket(p1.Data(), p1.Length()); | 349 InjectRtcpPacket(p1.Data(), p1.Length()); |
383 | 350 |
384 EXPECT_CALL(mock_rtt_feedback_, | 351 EXPECT_CALL(mock_receiver_feedback_, |
385 OnReceivedDelaySinceLastReport( | 352 OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1); |
386 kSourceSsrc, kLastSr, kDelayLastSr)).Times(1); | 353 EXPECT_CALL(mock_receiver_feedback_, OnReceivedCastFeedback(_)).Times(1); |
387 EXPECT_CALL(mock_sender_feedback_, OnReceivedCastFeedback(_)).Times(1); | |
388 | 354 |
389 // Enable receiving the cast feedback. | 355 // Enable receiving the cast feedback. |
390 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); | 356 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); |
391 | 357 |
392 TestRtcpPacketBuilder p2; | 358 TestRtcpPacketBuilder p2; |
393 p2.AddRr(kSenderSsrc, 1); | 359 p2.AddRr(kSenderSsrc, 1); |
394 p2.AddRb(kSourceSsrc); | 360 p2.AddRb(kSourceSsrc); |
395 p2.AddCast(kSenderSsrc, kSourceSsrc, kTargetDelay); | 361 p2.AddCast(kSenderSsrc, kSourceSsrc, kTargetDelay); |
396 | 362 |
397 // Expected to be pass through since the sender ssrc match our local ssrc. | 363 // Expected to be pass through since the sender ssrc match our local ssrc. |
398 InjectRtcpPacket(p2.Data(), p2.Length()); | 364 InjectRtcpPacket(p2.Data(), p2.Length()); |
399 } | 365 } |
400 | 366 |
401 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithCastVerification) { | 367 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithCastVerification) { |
402 SenderFeedbackCastVerification sender_feedback_cast_verification; | 368 RtcpMessageVerification verification; |
403 RtcpReceiver rtcp_receiver(cast_environment_, | 369 RtcpReceiver rtcp_receiver(&verification, kSourceSsrc); |
404 &sender_feedback_cast_verification, | |
405 &mock_receiver_feedback_, | |
406 &mock_rtt_feedback_, | |
407 kSourceSsrc); | |
408 | 370 |
409 EXPECT_CALL(mock_rtt_feedback_, | 371 EXPECT_CALL(verification, |
410 OnReceivedDelaySinceLastReport( | 372 OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1); |
411 kSourceSsrc, kLastSr, kDelayLastSr)).Times(1); | |
412 | 373 |
413 // Enable receiving the cast feedback. | 374 // Enable receiving the cast feedback. |
414 rtcp_receiver.SetRemoteSSRC(kSenderSsrc); | 375 rtcp_receiver.SetRemoteSSRC(kSenderSsrc); |
415 | 376 |
416 TestRtcpPacketBuilder p; | 377 TestRtcpPacketBuilder p; |
417 p.AddRr(kSenderSsrc, 1); | 378 p.AddRr(kSenderSsrc, 1); |
418 p.AddRb(kSourceSsrc); | 379 p.AddRb(kSourceSsrc); |
419 p.AddCast(kSenderSsrc, kSourceSsrc, kTargetDelay); | 380 p.AddCast(kSenderSsrc, kSourceSsrc, kTargetDelay); |
420 | 381 |
421 // Expected to be pass through since the sender ssrc match our local ssrc. | 382 // Expected to be pass through since the sender ssrc match our local ssrc. |
422 RtcpParser rtcp_parser(p.Data(), p.Length()); | 383 RtcpParser rtcp_parser(p.Data(), p.Length()); |
423 rtcp_receiver.IncomingRtcpPacket(&rtcp_parser); | 384 rtcp_receiver.IncomingRtcpPacket(&rtcp_parser); |
424 | 385 |
425 EXPECT_TRUE(sender_feedback_cast_verification.called()); | 386 EXPECT_TRUE(verification.OnReceivedCastFeedbackCalled()); |
426 } | 387 } |
427 | 388 |
428 TEST_F(RtcpReceiverTest, InjectReceiverReportWithReceiverLogVerificationBase) { | 389 TEST_F(RtcpReceiverTest, InjectReceiverReportWithReceiverLogVerificationBase) { |
429 static const uint32 kTimeBaseMs = 12345678; | 390 static const uint32 kTimeBaseMs = 12345678; |
430 static const uint32 kTimeDelayMs = 10; | 391 static const uint32 kTimeDelayMs = 10; |
431 static const uint32 kDelayDeltaMs = 123; | 392 static const uint32 kDelayDeltaMs = 123; |
432 base::SimpleTestTickClock testing_clock; | 393 base::SimpleTestTickClock testing_clock; |
433 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); | 394 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); |
434 | 395 |
435 RtcpReceiverCastLogVerification cast_log_verification; | 396 RtcpMessageVerification verification; |
436 RtcpReceiver rtcp_receiver(cast_environment_, | 397 RtcpReceiver rtcp_receiver(&verification, |
437 &mock_sender_feedback_, | |
438 &cast_log_verification, | |
439 &mock_rtt_feedback_, | |
440 kSourceSsrc); | 398 kSourceSsrc); |
441 rtcp_receiver.SetRemoteSSRC(kSenderSsrc); | 399 rtcp_receiver.SetRemoteSSRC(kSenderSsrc); |
442 rtcp_receiver.SetCastReceiverEventHistorySize(100); | 400 rtcp_receiver.SetCastReceiverEventHistorySize(100); |
443 | 401 |
444 RtcpReceiverLogMessage receiver_log; | 402 RtcpReceiverLogMessage receiver_log; |
445 RtcpReceiverFrameLogMessage frame_log(kRtpTimestamp); | 403 RtcpReceiverFrameLogMessage frame_log(kRtpTimestamp); |
446 RtcpReceiverEventLogMessage event_log; | 404 RtcpReceiverEventLogMessage event_log; |
447 | 405 |
448 event_log.type = FRAME_ACK_SENT; | 406 event_log.type = FRAME_ACK_SENT; |
449 event_log.event_timestamp = testing_clock.NowTicks(); | 407 event_log.event_timestamp = testing_clock.NowTicks(); |
450 event_log.delay_delta = base::TimeDelta::FromMilliseconds(kDelayDeltaMs); | 408 event_log.delay_delta = base::TimeDelta::FromMilliseconds(kDelayDeltaMs); |
451 frame_log.event_log_messages_.push_back(event_log); | 409 frame_log.event_log_messages_.push_back(event_log); |
452 | 410 |
453 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); | 411 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); |
454 event_log.type = PACKET_RECEIVED; | 412 event_log.type = PACKET_RECEIVED; |
455 event_log.event_timestamp = testing_clock.NowTicks(); | 413 event_log.event_timestamp = testing_clock.NowTicks(); |
456 event_log.packet_id = kLostPacketId1; | 414 event_log.packet_id = kLostPacketId1; |
457 frame_log.event_log_messages_.push_back(event_log); | 415 frame_log.event_log_messages_.push_back(event_log); |
458 | 416 |
459 event_log.type = PACKET_RECEIVED; | 417 event_log.type = PACKET_RECEIVED; |
460 event_log.event_timestamp = testing_clock.NowTicks(); | 418 event_log.event_timestamp = testing_clock.NowTicks(); |
461 event_log.packet_id = kLostPacketId2; | 419 event_log.packet_id = kLostPacketId2; |
462 frame_log.event_log_messages_.push_back(event_log); | 420 frame_log.event_log_messages_.push_back(event_log); |
463 | 421 |
464 receiver_log.push_back(frame_log); | 422 receiver_log.push_back(frame_log); |
465 | 423 |
466 cast_log_verification.SetExpectedReceiverLog(receiver_log); | 424 verification.SetExpectedReceiverLog(receiver_log); |
467 | 425 |
468 TestRtcpPacketBuilder p; | 426 TestRtcpPacketBuilder p; |
469 p.AddRr(kSenderSsrc, 1); | 427 p.AddRr(kSenderSsrc, 1); |
470 p.AddRb(kSourceSsrc); | 428 p.AddRb(kSourceSsrc); |
471 p.AddReceiverLog(kSenderSsrc); | 429 p.AddReceiverLog(kSenderSsrc); |
472 p.AddReceiverFrameLog(kRtpTimestamp, 3, kTimeBaseMs); | 430 p.AddReceiverFrameLog(kRtpTimestamp, 3, kTimeBaseMs); |
473 p.AddReceiverEventLog(kDelayDeltaMs, FRAME_ACK_SENT, 0); | 431 p.AddReceiverEventLog(kDelayDeltaMs, FRAME_ACK_SENT, 0); |
474 p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs); | 432 p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs); |
475 p.AddReceiverEventLog(kLostPacketId2, PACKET_RECEIVED, kTimeDelayMs); | 433 p.AddReceiverEventLog(kLostPacketId2, PACKET_RECEIVED, kTimeDelayMs); |
476 | 434 |
477 // Adds duplicated receiver event. | 435 // Adds duplicated receiver event. |
478 p.AddReceiverFrameLog(kRtpTimestamp, 3, kTimeBaseMs); | 436 p.AddReceiverFrameLog(kRtpTimestamp, 3, kTimeBaseMs); |
479 p.AddReceiverEventLog(kDelayDeltaMs, FRAME_ACK_SENT, 0); | 437 p.AddReceiverEventLog(kDelayDeltaMs, FRAME_ACK_SENT, 0); |
480 p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs); | 438 p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs); |
481 p.AddReceiverEventLog(kLostPacketId2, PACKET_RECEIVED, kTimeDelayMs); | 439 p.AddReceiverEventLog(kLostPacketId2, PACKET_RECEIVED, kTimeDelayMs); |
482 | 440 |
483 EXPECT_CALL(mock_rtt_feedback_, | 441 EXPECT_CALL(verification, |
484 OnReceivedDelaySinceLastReport( | 442 OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1); |
485 kSourceSsrc, kLastSr, kDelayLastSr)).Times(1); | |
486 | 443 |
487 RtcpParser rtcp_parser(p.Data(), p.Length()); | 444 RtcpParser rtcp_parser(p.Data(), p.Length()); |
488 rtcp_receiver.IncomingRtcpPacket(&rtcp_parser); | 445 rtcp_receiver.IncomingRtcpPacket(&rtcp_parser); |
489 | 446 |
490 EXPECT_TRUE(cast_log_verification.OnReceivedReceiverLogCalled()); | 447 EXPECT_TRUE(verification.OnReceivedReceiverLogCalled()); |
491 } | 448 } |
492 | 449 |
493 TEST_F(RtcpReceiverTest, InjectReceiverReportWithReceiverLogVerificationMulti) { | 450 TEST_F(RtcpReceiverTest, InjectReceiverReportWithReceiverLogVerificationMulti) { |
494 static const uint32 kTimeBaseMs = 12345678; | 451 static const uint32 kTimeBaseMs = 12345678; |
495 static const uint32 kTimeDelayMs = 10; | 452 static const uint32 kTimeDelayMs = 10; |
496 static const uint32 kDelayDeltaMs = 123; | 453 static const uint32 kDelayDeltaMs = 123; |
497 base::SimpleTestTickClock testing_clock; | 454 base::SimpleTestTickClock testing_clock; |
498 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); | 455 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); |
499 | 456 |
500 RtcpReceiverCastLogVerification cast_log_verification; | 457 RtcpMessageVerification verification; |
501 RtcpReceiver rtcp_receiver(cast_environment_, | 458 RtcpReceiver rtcp_receiver(&verification, |
502 &mock_sender_feedback_, | |
503 &cast_log_verification, | |
504 &mock_rtt_feedback_, | |
505 kSourceSsrc); | 459 kSourceSsrc); |
506 rtcp_receiver.SetRemoteSSRC(kSenderSsrc); | 460 rtcp_receiver.SetRemoteSSRC(kSenderSsrc); |
507 | 461 |
508 RtcpReceiverLogMessage receiver_log; | 462 RtcpReceiverLogMessage receiver_log; |
509 | 463 |
510 for (int j = 0; j < 100; ++j) { | 464 for (int j = 0; j < 100; ++j) { |
511 RtcpReceiverFrameLogMessage frame_log(kRtpTimestamp); | 465 RtcpReceiverFrameLogMessage frame_log(kRtpTimestamp); |
512 RtcpReceiverEventLogMessage event_log; | 466 RtcpReceiverEventLogMessage event_log; |
513 event_log.type = FRAME_ACK_SENT; | 467 event_log.type = FRAME_ACK_SENT; |
514 event_log.event_timestamp = testing_clock.NowTicks(); | 468 event_log.event_timestamp = testing_clock.NowTicks(); |
515 event_log.delay_delta = base::TimeDelta::FromMilliseconds(kDelayDeltaMs); | 469 event_log.delay_delta = base::TimeDelta::FromMilliseconds(kDelayDeltaMs); |
516 frame_log.event_log_messages_.push_back(event_log); | 470 frame_log.event_log_messages_.push_back(event_log); |
517 receiver_log.push_back(frame_log); | 471 receiver_log.push_back(frame_log); |
518 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); | 472 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); |
519 } | 473 } |
520 | 474 |
521 cast_log_verification.SetExpectedReceiverLog(receiver_log); | 475 verification.SetExpectedReceiverLog(receiver_log); |
522 | 476 |
523 TestRtcpPacketBuilder p; | 477 TestRtcpPacketBuilder p; |
524 p.AddRr(kSenderSsrc, 1); | 478 p.AddRr(kSenderSsrc, 1); |
525 p.AddRb(kSourceSsrc); | 479 p.AddRb(kSourceSsrc); |
526 p.AddReceiverLog(kSenderSsrc); | 480 p.AddReceiverLog(kSenderSsrc); |
527 for (int i = 0; i < 100; ++i) { | 481 for (int i = 0; i < 100; ++i) { |
528 p.AddReceiverFrameLog(kRtpTimestamp, 1, kTimeBaseMs + i * kTimeDelayMs); | 482 p.AddReceiverFrameLog(kRtpTimestamp, 1, kTimeBaseMs + i * kTimeDelayMs); |
529 p.AddReceiverEventLog(kDelayDeltaMs, FRAME_ACK_SENT, 0); | 483 p.AddReceiverEventLog(kDelayDeltaMs, FRAME_ACK_SENT, 0); |
530 } | 484 } |
531 | 485 |
532 EXPECT_CALL(mock_rtt_feedback_, | 486 EXPECT_CALL(verification, |
533 OnReceivedDelaySinceLastReport( | 487 OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1); |
534 kSourceSsrc, kLastSr, kDelayLastSr)).Times(1); | |
535 | 488 |
536 RtcpParser rtcp_parser(p.Data(), p.Length()); | 489 RtcpParser rtcp_parser(p.Data(), p.Length()); |
537 rtcp_receiver.IncomingRtcpPacket(&rtcp_parser); | 490 rtcp_receiver.IncomingRtcpPacket(&rtcp_parser); |
538 | 491 |
539 EXPECT_TRUE(cast_log_verification.OnReceivedReceiverLogCalled()); | 492 EXPECT_TRUE(verification.OnReceivedReceiverLogCalled()); |
540 } | 493 } |
541 | 494 |
542 } // namespace cast | 495 } // namespace cast |
543 } // namespace media | 496 } // namespace media |
OLD | NEW |