OLD | NEW |
---|---|
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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 <stdint.h> | 5 #include <stdint.h> |
6 | 6 |
7 #include "base/test/simple_test_tick_clock.h" | 7 #include "base/test/simple_test_tick_clock.h" |
8 #include "media/cast/cast_defines.h" | 8 #include "media/cast/cast_defines.h" |
9 #include "media/cast/cast_environment.h" | |
10 #include "media/cast/net/cast_transport_config.h" | 9 #include "media/cast/net/cast_transport_config.h" |
11 #include "media/cast/net/cast_transport_sender_impl.h" | 10 #include "media/cast/net/cast_transport_sender_impl.h" |
12 #include "media/cast/net/pacing/paced_sender.h" | 11 #include "media/cast/net/pacing/paced_sender.h" |
13 #include "media/cast/net/rtcp/mock_rtcp_receiver_feedback.h" | 12 #include "media/cast/net/rtcp/mock_rtcp_receiver_feedback.h" |
14 #include "media/cast/net/rtcp/mock_rtcp_sender_feedback.h" | |
15 #include "media/cast/net/rtcp/rtcp.h" | 13 #include "media/cast/net/rtcp/rtcp.h" |
16 #include "media/cast/net/rtcp/test_rtcp_packet_builder.h" | 14 #include "media/cast/net/rtcp/test_rtcp_packet_builder.h" |
17 #include "media/cast/test/fake_single_thread_task_runner.h" | 15 #include "media/cast/test/fake_single_thread_task_runner.h" |
18 #include "testing/gmock/include/gmock/gmock.h" | 16 #include "testing/gmock/include/gmock/gmock.h" |
19 | 17 |
20 namespace media { | 18 namespace media { |
21 namespace cast { | 19 namespace cast { |
22 | 20 |
23 using testing::_; | 21 using testing::_; |
24 | 22 |
25 static const uint32 kSenderSsrc = 0x10203; | 23 static const uint32 kSenderSsrc = 0x10203; |
26 static const uint32 kReceiverSsrc = 0x40506; | 24 static const uint32 kReceiverSsrc = 0x40506; |
27 static const std::string kCName("test@10.1.1.1"); | 25 static const std::string kCName("test@10.1.1.1"); |
28 static const uint32 kRtcpIntervalMs = 500; | |
29 static const int64 kAddedDelay = 123; | 26 static const int64 kAddedDelay = 123; |
30 static const int64 kAddedShortDelay = 100; | 27 static const int64 kAddedShortDelay = 100; |
31 | 28 |
32 class RtcpTestPacketSender : public PacketSender { | 29 class RtcpTestPacketSender : public PacketSender { |
33 public: | 30 public: |
34 explicit RtcpTestPacketSender(base::SimpleTestTickClock* testing_clock) | 31 explicit RtcpTestPacketSender(base::SimpleTestTickClock* testing_clock) |
35 : drop_packets_(false), | 32 : drop_packets_(false), |
36 short_delay_(false), | 33 short_delay_(false), |
37 rtcp_receiver_(NULL), | 34 rtcp_receiver_(NULL), |
38 testing_clock_(testing_clock) {} | 35 testing_clock_(testing_clock) {} |
(...skipping 25 matching lines...) Expand all Loading... | |
64 bool drop_packets_; | 61 bool drop_packets_; |
65 bool short_delay_; | 62 bool short_delay_; |
66 Rtcp* rtcp_receiver_; | 63 Rtcp* rtcp_receiver_; |
67 base::SimpleTestTickClock* testing_clock_; | 64 base::SimpleTestTickClock* testing_clock_; |
68 | 65 |
69 DISALLOW_COPY_AND_ASSIGN(RtcpTestPacketSender); | 66 DISALLOW_COPY_AND_ASSIGN(RtcpTestPacketSender); |
70 }; | 67 }; |
71 | 68 |
72 class LocalRtcpTransport : public PacedPacketSender { | 69 class LocalRtcpTransport : public PacedPacketSender { |
73 public: | 70 public: |
74 LocalRtcpTransport(scoped_refptr<CastEnvironment> cast_environment, | 71 LocalRtcpTransport(base::SimpleTestTickClock* testing_clock) |
miu
2014/07/16 19:58:03
explicit
Alpha Left Google
2014/07/17 01:01:46
Done.
| |
75 base::SimpleTestTickClock* testing_clock) | |
76 : drop_packets_(false), | 72 : drop_packets_(false), |
77 short_delay_(false), | 73 short_delay_(false), |
78 testing_clock_(testing_clock) {} | 74 testing_clock_(testing_clock) {} |
79 | 75 |
80 void set_rtcp_receiver(Rtcp* rtcp) { rtcp_ = rtcp; } | 76 void set_rtcp_receiver(Rtcp* rtcp) { rtcp_ = rtcp; } |
81 | 77 |
82 void set_short_delay() { short_delay_ = true; } | 78 void set_short_delay() { short_delay_ = true; } |
83 | 79 |
84 void set_drop_packets(bool drop_packets) { drop_packets_ = drop_packets; } | 80 void set_drop_packets(bool drop_packets) { drop_packets_ = drop_packets; } |
85 | 81 |
(...skipping 25 matching lines...) Expand all Loading... | |
111 | 107 |
112 virtual void CancelSendingPacket( | 108 virtual void CancelSendingPacket( |
113 const PacketKey& packet_key) OVERRIDE { | 109 const PacketKey& packet_key) OVERRIDE { |
114 } | 110 } |
115 | 111 |
116 private: | 112 private: |
117 bool drop_packets_; | 113 bool drop_packets_; |
118 bool short_delay_; | 114 bool short_delay_; |
119 Rtcp* rtcp_; | 115 Rtcp* rtcp_; |
120 base::SimpleTestTickClock* testing_clock_; | 116 base::SimpleTestTickClock* testing_clock_; |
121 scoped_refptr<CastEnvironment> cast_environment_; | |
122 | 117 |
123 DISALLOW_COPY_AND_ASSIGN(LocalRtcpTransport); | 118 DISALLOW_COPY_AND_ASSIGN(LocalRtcpTransport); |
124 }; | 119 }; |
125 | 120 |
126 class RtcpPeer : public Rtcp { | 121 class MockReceiverStats : public RtpReceiverStatistics { |
127 public: | 122 public: |
128 RtcpPeer(scoped_refptr<CastEnvironment> cast_environment, | 123 MockReceiverStats() {} |
129 RtcpSenderFeedback* sender_feedback, | 124 virtual ~MockReceiverStats() {} |
130 CastTransportSender* const transport_sender, | |
131 PacedPacketSender* paced_packet_sender, | |
132 RtpReceiverStatistics* rtp_receiver_statistics, | |
133 RtcpMode rtcp_mode, | |
134 const base::TimeDelta& rtcp_interval, | |
135 uint32 local_ssrc, | |
136 uint32 remote_ssrc, | |
137 const std::string& c_name) | |
138 : Rtcp(cast_environment, | |
139 sender_feedback, | |
140 transport_sender, | |
141 paced_packet_sender, | |
142 rtp_receiver_statistics, | |
143 rtcp_mode, | |
144 rtcp_interval, | |
145 local_ssrc, | |
146 remote_ssrc, | |
147 c_name, | |
148 AUDIO_EVENT) {} | |
149 | 125 |
150 using Rtcp::OnReceivedNtp; | 126 virtual void GetStatistics(uint8* fraction_lost, |
151 using Rtcp::OnReceivedLipSyncInfo; | 127 uint32* cumulative_lost, |
128 uint32* extended_high_sequence_number, | |
129 uint32* jitter) OVERRIDE { | |
130 *fraction_lost = 0; | |
131 *cumulative_lost = 0; | |
132 *extended_high_sequence_number = 0; | |
133 *jitter = 0; | |
134 } | |
135 | |
136 private: | |
137 DISALLOW_COPY_AND_ASSIGN(MockReceiverStats); | |
138 }; | |
139 | |
140 class MockFrameSender { | |
141 public: | |
142 MockFrameSender() {} | |
143 virtual ~MockFrameSender() {} | |
144 | |
145 MOCK_METHOD1(OnReceivedCastFeedback, | |
146 void(const RtcpCastMessage& cast_message)); | |
147 MOCK_METHOD4(OnReceivedRtt, | |
148 void(base::TimeDelta rtt, | |
149 base::TimeDelta avg_rtt, | |
150 base::TimeDelta min_rtt, | |
151 base::TimeDelta max_rtt)); | |
152 private: | |
153 DISALLOW_COPY_AND_ASSIGN(MockFrameSender); | |
152 }; | 154 }; |
153 | 155 |
154 class RtcpTest : public ::testing::Test { | 156 class RtcpTest : public ::testing::Test { |
155 protected: | 157 protected: |
156 RtcpTest() | 158 RtcpTest() |
157 : testing_clock_(new base::SimpleTestTickClock()), | 159 : testing_clock_(new base::SimpleTestTickClock()), |
158 task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)), | 160 task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)), |
159 cast_environment_(new CastEnvironment( | |
160 scoped_ptr<base::TickClock>(testing_clock_).Pass(), | |
161 task_runner_, | |
162 task_runner_, | |
163 task_runner_)), | |
164 sender_to_receiver_(testing_clock_), | 161 sender_to_receiver_(testing_clock_), |
165 receiver_to_sender_(cast_environment_, testing_clock_) { | 162 receiver_to_sender_(testing_clock_) { |
166 testing_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks()); | 163 testing_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks()); |
167 net::IPEndPoint dummy_endpoint; | |
168 transport_sender_.reset(new CastTransportSenderImpl( | |
169 NULL, | |
170 testing_clock_, | |
171 dummy_endpoint, | |
172 base::Bind(&UpdateCastTransportStatus), | |
173 BulkRawEventsCallback(), | |
174 base::TimeDelta(), | |
175 task_runner_, | |
176 &sender_to_receiver_)); | |
177 CastTransportRtpConfig config; | |
178 config.ssrc = kSenderSsrc; | |
179 config.rtp_payload_type = 127; | |
180 config.stored_frames = 1; | |
181 transport_sender_->InitializeAudio(config); | |
182 EXPECT_CALL(mock_sender_feedback_, OnReceivedCastFeedback(_)).Times(0); | |
183 } | 164 } |
184 | 165 |
185 virtual ~RtcpTest() {} | 166 virtual ~RtcpTest() {} |
186 | 167 |
187 static void UpdateCastTransportStatus(CastTransportStatus status) { | 168 static void UpdateCastTransportStatus(CastTransportStatus status) { |
188 bool result = (status == TRANSPORT_AUDIO_INITIALIZED || | 169 bool result = (status == TRANSPORT_AUDIO_INITIALIZED || |
189 status == TRANSPORT_VIDEO_INITIALIZED); | 170 status == TRANSPORT_VIDEO_INITIALIZED); |
190 EXPECT_TRUE(result); | 171 EXPECT_TRUE(result); |
191 } | 172 } |
192 | 173 |
193 void RunTasks(int during_ms) { | 174 void RunTasks(int during_ms) { |
194 for (int i = 0; i < during_ms; ++i) { | 175 for (int i = 0; i < during_ms; ++i) { |
195 // Call process the timers every 1 ms. | 176 // Call process the timers every 1 ms. |
196 testing_clock_->Advance(base::TimeDelta::FromMilliseconds(1)); | 177 testing_clock_->Advance(base::TimeDelta::FromMilliseconds(1)); |
197 task_runner_->RunTasks(); | 178 task_runner_->RunTasks(); |
198 } | 179 } |
199 } | 180 } |
200 | 181 |
201 base::SimpleTestTickClock* testing_clock_; // Owned by CastEnvironment. | 182 base::SimpleTestTickClock* testing_clock_; // Owned by CastEnvironment. |
202 scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_; | 183 scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_; |
203 scoped_refptr<CastEnvironment> cast_environment_; | 184 LocalRtcpTransport sender_to_receiver_; |
204 RtcpTestPacketSender sender_to_receiver_; | |
205 scoped_ptr<CastTransportSenderImpl> transport_sender_; | |
206 LocalRtcpTransport receiver_to_sender_; | 185 LocalRtcpTransport receiver_to_sender_; |
207 MockRtcpSenderFeedback mock_sender_feedback_; | 186 MockFrameSender mock_frame_sender_; |
187 MockReceiverStats stats_; | |
208 | 188 |
209 DISALLOW_COPY_AND_ASSIGN(RtcpTest); | 189 DISALLOW_COPY_AND_ASSIGN(RtcpTest); |
210 }; | 190 }; |
211 | 191 |
212 TEST_F(RtcpTest, TimeToSend) { | 192 TEST_F(RtcpTest, BasicSenderReport) { |
213 const base::TimeTicks start_time = testing_clock_->NowTicks(); | 193 Rtcp rtcp(base::Bind(&MockFrameSender::OnReceivedCastFeedback, |
214 Rtcp rtcp(cast_environment_, | 194 base::Unretained(&mock_frame_sender_)), |
215 &mock_sender_feedback_, | 195 base::Bind(&MockFrameSender::OnReceivedRtt, |
216 transport_sender_.get(), | 196 base::Unretained(&mock_frame_sender_)), |
217 &receiver_to_sender_, | 197 RtcpLogMessageCallback(), |
218 NULL, | 198 testing_clock_, |
219 kRtcpCompound, | 199 &sender_to_receiver_, |
220 base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), | |
221 kSenderSsrc, | 200 kSenderSsrc, |
222 kReceiverSsrc, | 201 kReceiverSsrc, |
223 kCName, | 202 kCName); |
224 AUDIO_EVENT); | |
225 receiver_to_sender_.set_rtcp_receiver(&rtcp); | |
226 EXPECT_LE(start_time, rtcp.TimeToSendNextRtcpReport()); | |
227 EXPECT_GE( | |
228 start_time + base::TimeDelta::FromMilliseconds(kRtcpIntervalMs * 3 / 2), | |
229 rtcp.TimeToSendNextRtcpReport()); | |
230 base::TimeDelta delta = rtcp.TimeToSendNextRtcpReport() - start_time; | |
231 testing_clock_->Advance(delta); | |
232 EXPECT_EQ(testing_clock_->NowTicks(), rtcp.TimeToSendNextRtcpReport()); | |
233 } | |
234 | |
235 TEST_F(RtcpTest, BasicSenderReport) { | |
236 Rtcp rtcp(cast_environment_, | |
237 &mock_sender_feedback_, | |
238 transport_sender_.get(), | |
239 NULL, | |
240 NULL, | |
241 kRtcpCompound, | |
242 base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), | |
243 kSenderSsrc, | |
244 kReceiverSsrc, | |
245 kCName, | |
246 AUDIO_EVENT); | |
247 sender_to_receiver_.set_rtcp_receiver(&rtcp); | 203 sender_to_receiver_.set_rtcp_receiver(&rtcp); |
248 rtcp.SendRtcpFromRtpSender(base::TimeTicks(), 0); | 204 rtcp.SendRtcpFromRtpSender(base::TimeTicks(), 0, 1, 1); |
249 } | 205 } |
250 | 206 |
251 TEST_F(RtcpTest, BasicReceiverReport) { | 207 TEST_F(RtcpTest, BasicReceiverReport) { |
252 Rtcp rtcp(cast_environment_, | 208 Rtcp rtcp(base::Bind(&MockFrameSender::OnReceivedCastFeedback, |
253 &mock_sender_feedback_, | 209 base::Unretained(&mock_frame_sender_)), |
254 NULL, | 210 base::Bind(&MockFrameSender::OnReceivedRtt, |
211 base::Unretained(&mock_frame_sender_)), | |
212 RtcpLogMessageCallback(), | |
213 testing_clock_, | |
255 &receiver_to_sender_, | 214 &receiver_to_sender_, |
256 NULL, | |
257 kRtcpCompound, | |
258 base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), | |
259 kSenderSsrc, | 215 kSenderSsrc, |
260 kReceiverSsrc, | 216 kReceiverSsrc, |
261 kCName, | 217 kCName); |
262 AUDIO_EVENT); | |
263 receiver_to_sender_.set_rtcp_receiver(&rtcp); | 218 receiver_to_sender_.set_rtcp_receiver(&rtcp); |
264 rtcp.SendRtcpFromRtpReceiver(NULL, NULL); | 219 rtcp.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_); |
265 } | 220 } |
266 | 221 |
267 TEST_F(RtcpTest, BasicCast) { | 222 TEST_F(RtcpTest, BasicCast) { |
268 EXPECT_CALL(mock_sender_feedback_, OnReceivedCastFeedback(_)).Times(1); | 223 EXPECT_CALL(mock_frame_sender_, OnReceivedCastFeedback(_)).Times(1); |
269 | 224 |
270 // Media receiver. | 225 // Media sender. |
271 Rtcp rtcp(cast_environment_, | 226 Rtcp rtcp(base::Bind(&MockFrameSender::OnReceivedCastFeedback, |
272 &mock_sender_feedback_, | 227 base::Unretained(&mock_frame_sender_)), |
273 NULL, | 228 base::Bind(&MockFrameSender::OnReceivedRtt, |
229 base::Unretained(&mock_frame_sender_)), | |
230 RtcpLogMessageCallback(), | |
231 testing_clock_, | |
274 &receiver_to_sender_, | 232 &receiver_to_sender_, |
275 NULL, | |
276 kRtcpReducedSize, | |
277 base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), | |
278 kSenderSsrc, | 233 kSenderSsrc, |
279 kSenderSsrc, | 234 kSenderSsrc, |
280 kCName, | 235 kCName); |
281 AUDIO_EVENT); | |
282 receiver_to_sender_.set_rtcp_receiver(&rtcp); | 236 receiver_to_sender_.set_rtcp_receiver(&rtcp); |
283 RtcpCastMessage cast_message(kSenderSsrc); | 237 RtcpCastMessage cast_message(kSenderSsrc); |
284 cast_message.ack_frame_id_ = kAckFrameId; | 238 cast_message.ack_frame_id_ = kAckFrameId; |
285 PacketIdSet missing_packets; | 239 PacketIdSet missing_packets; |
286 cast_message.missing_frames_and_packets_[kLostFrameId] = missing_packets; | 240 cast_message.missing_frames_and_packets_[kLostFrameId] = missing_packets; |
287 | 241 |
288 missing_packets.insert(kLostPacketId1); | 242 missing_packets.insert(kLostPacketId1); |
289 missing_packets.insert(kLostPacketId2); | 243 missing_packets.insert(kLostPacketId2); |
290 missing_packets.insert(kLostPacketId3); | 244 missing_packets.insert(kLostPacketId3); |
291 cast_message.missing_frames_and_packets_[kFrameIdWithLostPackets] = | 245 cast_message.missing_frames_and_packets_[kFrameIdWithLostPackets] = |
292 missing_packets; | 246 missing_packets; |
293 rtcp.SendRtcpFromRtpReceiver(&cast_message, NULL); | 247 rtcp.SendRtcpFromRtpReceiver(&cast_message, base::TimeDelta(), NULL, NULL); |
294 } | 248 } |
295 | 249 |
296 TEST_F(RtcpTest, RttReducedSizeRtcp) { | 250 TEST_F(RtcpTest, RttReducedSizeRtcp) { |
297 // Media receiver. | 251 // Media receiver. |
298 Rtcp rtcp_receiver(cast_environment_, | 252 Rtcp rtcp_receiver(RtcpCastMessageCallback(), |
299 &mock_sender_feedback_, | 253 RtcpRttCallback(), |
300 NULL, | 254 RtcpLogMessageCallback(), |
255 testing_clock_, | |
301 &receiver_to_sender_, | 256 &receiver_to_sender_, |
302 NULL, | |
303 kRtcpReducedSize, | |
304 base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), | |
305 kReceiverSsrc, | 257 kReceiverSsrc, |
306 kSenderSsrc, | 258 kSenderSsrc, |
307 kCName, | 259 kCName); |
308 AUDIO_EVENT); | |
309 | 260 |
310 // Media sender. | 261 // Media sender. |
311 Rtcp rtcp_sender(cast_environment_, | 262 Rtcp rtcp_sender(base::Bind(&MockFrameSender::OnReceivedCastFeedback, |
312 &mock_sender_feedback_, | 263 base::Unretained(&mock_frame_sender_)), |
313 transport_sender_.get(), | 264 base::Bind(&MockFrameSender::OnReceivedRtt, |
314 NULL, | 265 base::Unretained(&mock_frame_sender_)), |
315 NULL, | 266 RtcpLogMessageCallback(), |
316 kRtcpReducedSize, | 267 testing_clock_, |
317 base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), | 268 &sender_to_receiver_, |
318 kSenderSsrc, | 269 kSenderSsrc, |
319 kReceiverSsrc, | 270 kReceiverSsrc, |
320 kCName, | 271 kCName); |
321 AUDIO_EVENT); | |
322 | 272 |
323 sender_to_receiver_.set_rtcp_receiver(&rtcp_receiver); | 273 sender_to_receiver_.set_rtcp_receiver(&rtcp_receiver); |
324 receiver_to_sender_.set_rtcp_receiver(&rtcp_sender); | 274 receiver_to_sender_.set_rtcp_receiver(&rtcp_sender); |
325 | 275 |
326 base::TimeDelta rtt; | 276 base::TimeDelta rtt; |
327 base::TimeDelta avg_rtt; | 277 base::TimeDelta avg_rtt; |
328 base::TimeDelta min_rtt; | 278 base::TimeDelta min_rtt; |
329 base::TimeDelta max_rtt; | 279 base::TimeDelta max_rtt; |
330 EXPECT_FALSE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | 280 EXPECT_FALSE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); |
331 EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | 281 EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); |
332 | 282 |
333 rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 1); | 283 rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 1, 1, 1); |
334 RunTasks(33); | 284 RunTasks(33); |
335 rtcp_receiver.SendRtcpFromRtpReceiver(NULL, NULL); | 285 rtcp_receiver.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_); |
336 EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | 286 EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); |
337 EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | 287 EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); |
338 EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 2); | 288 EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 2); |
339 EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 2); | 289 EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 2); |
340 EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 2); | 290 EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 2); |
341 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); | 291 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); |
342 rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 2); | 292 rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 2, 1, 1); |
343 RunTasks(33); | 293 RunTasks(33); |
344 EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | 294 EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); |
345 | 295 |
346 EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 2); | 296 EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 2); |
347 EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 2); | 297 EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 2); |
348 EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 2); | 298 EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 2); |
349 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); | 299 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); |
350 } | 300 } |
351 | 301 |
352 TEST_F(RtcpTest, Rtt) { | 302 TEST_F(RtcpTest, Rtt) { |
353 // Media receiver. | 303 // Media receiver. |
354 Rtcp rtcp_receiver(cast_environment_, | 304 Rtcp rtcp_receiver(RtcpCastMessageCallback(), |
355 &mock_sender_feedback_, | 305 RtcpRttCallback(), |
356 NULL, | 306 RtcpLogMessageCallback(), |
307 testing_clock_, | |
357 &receiver_to_sender_, | 308 &receiver_to_sender_, |
358 NULL, | |
359 kRtcpCompound, | |
360 base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), | |
361 kReceiverSsrc, | 309 kReceiverSsrc, |
362 kSenderSsrc, | 310 kSenderSsrc, |
363 kCName, | 311 kCName); |
364 AUDIO_EVENT); | |
365 | 312 |
366 // Media sender. | 313 // Media sender. |
367 Rtcp rtcp_sender(cast_environment_, | 314 Rtcp rtcp_sender(base::Bind(&MockFrameSender::OnReceivedCastFeedback, |
368 &mock_sender_feedback_, | 315 base::Unretained(&mock_frame_sender_)), |
369 transport_sender_.get(), | 316 base::Bind(&MockFrameSender::OnReceivedRtt, |
370 NULL, | 317 base::Unretained(&mock_frame_sender_)), |
371 NULL, | 318 RtcpLogMessageCallback(), |
372 kRtcpCompound, | 319 testing_clock_, |
373 base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), | 320 &sender_to_receiver_, |
374 kSenderSsrc, | 321 kSenderSsrc, |
375 kReceiverSsrc, | 322 kReceiverSsrc, |
376 kCName, | 323 kCName); |
377 AUDIO_EVENT); | |
378 | 324 |
379 receiver_to_sender_.set_rtcp_receiver(&rtcp_sender); | 325 receiver_to_sender_.set_rtcp_receiver(&rtcp_sender); |
380 sender_to_receiver_.set_rtcp_receiver(&rtcp_receiver); | 326 sender_to_receiver_.set_rtcp_receiver(&rtcp_receiver); |
381 | 327 |
382 base::TimeDelta rtt; | 328 base::TimeDelta rtt; |
383 base::TimeDelta avg_rtt; | 329 base::TimeDelta avg_rtt; |
384 base::TimeDelta min_rtt; | 330 base::TimeDelta min_rtt; |
385 base::TimeDelta max_rtt; | 331 base::TimeDelta max_rtt; |
386 EXPECT_FALSE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | 332 EXPECT_FALSE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); |
387 EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | 333 EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); |
388 | 334 |
389 rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 1); | 335 rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 1, 1, 1); |
390 RunTasks(33); | 336 RunTasks(33); |
391 rtcp_receiver.SendRtcpFromRtpReceiver(NULL, NULL); | 337 rtcp_receiver.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_); |
392 | 338 |
393 EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | 339 EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); |
394 RunTasks(33); | 340 RunTasks(33); |
395 | 341 |
396 EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | 342 EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); |
397 RunTasks(33); | 343 RunTasks(33); |
398 | 344 |
399 EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 2); | 345 EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 2); |
400 EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 2); | 346 EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 2); |
401 EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 2); | 347 EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 2); |
402 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); | 348 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); |
403 | 349 |
404 rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 2); | 350 rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 2, 1, 1); |
405 RunTasks(33); | 351 RunTasks(33); |
406 EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | 352 EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); |
407 EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 2); | 353 EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 2); |
408 EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 2); | 354 EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 2); |
409 EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 2); | 355 EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 2); |
410 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); | 356 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); |
411 | 357 |
412 receiver_to_sender_.set_short_delay(); | 358 receiver_to_sender_.set_short_delay(); |
413 sender_to_receiver_.set_short_delay(); | 359 sender_to_receiver_.set_short_delay(); |
414 rtcp_receiver.SendRtcpFromRtpReceiver(NULL, NULL); | 360 rtcp_receiver.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_); |
415 EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | 361 EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); |
416 EXPECT_NEAR(kAddedDelay + kAddedShortDelay, rtt.InMilliseconds(), 2); | 362 EXPECT_NEAR(kAddedDelay + kAddedShortDelay, rtt.InMilliseconds(), 2); |
417 EXPECT_NEAR( | 363 EXPECT_NEAR( |
418 (kAddedShortDelay + 3 * kAddedDelay) / 2, avg_rtt.InMilliseconds(), 2); | 364 (kAddedShortDelay + 3 * kAddedDelay) / 2, avg_rtt.InMilliseconds(), 2); |
419 EXPECT_NEAR(kAddedDelay + kAddedShortDelay, min_rtt.InMilliseconds(), 2); | 365 EXPECT_NEAR(kAddedDelay + kAddedShortDelay, min_rtt.InMilliseconds(), 2); |
420 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); | 366 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); |
421 | 367 |
422 rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 3); | 368 rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 3, 1, 1); |
423 RunTasks(33); | 369 RunTasks(33); |
424 EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | 370 EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); |
425 EXPECT_NEAR(2 * kAddedShortDelay, rtt.InMilliseconds(), 1); | 371 EXPECT_NEAR(2 * kAddedShortDelay, rtt.InMilliseconds(), 1); |
426 EXPECT_NEAR((2 * kAddedShortDelay + 2 * kAddedDelay) / 2, | 372 EXPECT_NEAR((2 * kAddedShortDelay + 2 * kAddedDelay) / 2, |
427 avg_rtt.InMilliseconds(), | 373 avg_rtt.InMilliseconds(), |
428 1); | 374 1); |
429 EXPECT_NEAR(2 * kAddedShortDelay, min_rtt.InMilliseconds(), 2); | 375 EXPECT_NEAR(2 * kAddedShortDelay, min_rtt.InMilliseconds(), 2); |
430 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); | 376 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); |
431 | 377 |
432 rtcp_receiver.SendRtcpFromRtpReceiver(NULL, NULL); | 378 rtcp_receiver.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_); |
433 EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | 379 EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); |
434 EXPECT_NEAR(2 * kAddedShortDelay, rtt.InMilliseconds(), 2); | 380 EXPECT_NEAR(2 * kAddedShortDelay, rtt.InMilliseconds(), 2); |
435 EXPECT_NEAR(2 * kAddedShortDelay, min_rtt.InMilliseconds(), 2); | 381 EXPECT_NEAR(2 * kAddedShortDelay, min_rtt.InMilliseconds(), 2); |
436 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); | 382 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); |
437 | 383 |
438 rtcp_receiver.SendRtcpFromRtpReceiver(NULL, NULL); | 384 rtcp_receiver.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_); |
439 EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | 385 EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); |
440 EXPECT_NEAR(2 * kAddedShortDelay, rtt.InMilliseconds(), 2); | 386 EXPECT_NEAR(2 * kAddedShortDelay, rtt.InMilliseconds(), 2); |
441 EXPECT_NEAR(2 * kAddedShortDelay, min_rtt.InMilliseconds(), 2); | 387 EXPECT_NEAR(2 * kAddedShortDelay, min_rtt.InMilliseconds(), 2); |
442 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); | 388 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2); |
443 } | 389 } |
444 | 390 |
445 TEST_F(RtcpTest, RttWithPacketLoss) { | 391 TEST_F(RtcpTest, RttWithPacketLoss) { |
446 // Media receiver. | 392 // Media receiver. |
447 Rtcp rtcp_receiver(cast_environment_, | 393 Rtcp rtcp_receiver(RtcpCastMessageCallback(), |
448 &mock_sender_feedback_, | 394 RtcpRttCallback(), |
449 NULL, | 395 RtcpLogMessageCallback(), |
396 testing_clock_, | |
450 &receiver_to_sender_, | 397 &receiver_to_sender_, |
451 NULL, | |
452 kRtcpReducedSize, | |
453 base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), | |
454 kReceiverSsrc, | 398 kReceiverSsrc, |
455 kSenderSsrc, | 399 kSenderSsrc, |
456 kCName, | 400 kCName); |
457 AUDIO_EVENT); | |
458 | 401 |
459 // Media sender. | 402 // Media sender. |
460 Rtcp rtcp_sender(cast_environment_, | 403 Rtcp rtcp_sender(base::Bind(&MockFrameSender::OnReceivedCastFeedback, |
461 &mock_sender_feedback_, | 404 base::Unretained(&mock_frame_sender_)), |
462 transport_sender_.get(), | 405 base::Bind(&MockFrameSender::OnReceivedRtt, |
463 NULL, | 406 base::Unretained(&mock_frame_sender_)), |
464 NULL, | 407 RtcpLogMessageCallback(), |
465 kRtcpReducedSize, | 408 testing_clock_, |
466 base::TimeDelta::FromMilliseconds(kRtcpIntervalMs), | 409 &sender_to_receiver_, |
467 kSenderSsrc, | 410 kSenderSsrc, |
468 kReceiverSsrc, | 411 kReceiverSsrc, |
469 kCName, | 412 kCName); |
470 AUDIO_EVENT); | |
471 | 413 |
472 receiver_to_sender_.set_rtcp_receiver(&rtcp_sender); | 414 receiver_to_sender_.set_rtcp_receiver(&rtcp_sender); |
473 sender_to_receiver_.set_rtcp_receiver(&rtcp_receiver); | 415 sender_to_receiver_.set_rtcp_receiver(&rtcp_receiver); |
474 | 416 |
475 rtcp_receiver.SendRtcpFromRtpReceiver(NULL, NULL); | 417 rtcp_receiver.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_); |
476 rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 0); | 418 rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 0, 1, 1); |
477 RunTasks(33); | 419 RunTasks(33); |
478 | 420 |
479 base::TimeDelta rtt; | 421 base::TimeDelta rtt; |
480 base::TimeDelta avg_rtt; | 422 base::TimeDelta avg_rtt; |
481 base::TimeDelta min_rtt; | 423 base::TimeDelta min_rtt; |
482 base::TimeDelta max_rtt; | 424 base::TimeDelta max_rtt; |
483 EXPECT_FALSE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | 425 EXPECT_FALSE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); |
484 EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | 426 EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); |
485 EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 1); | 427 EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 1); |
486 EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 1); | 428 EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 1); |
487 EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 1); | 429 EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 1); |
488 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 1); | 430 EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 1); |
489 | 431 |
490 receiver_to_sender_.set_short_delay(); | 432 receiver_to_sender_.set_short_delay(); |
491 sender_to_receiver_.set_short_delay(); | 433 sender_to_receiver_.set_short_delay(); |
492 receiver_to_sender_.set_drop_packets(true); | 434 receiver_to_sender_.set_drop_packets(true); |
493 | 435 |
494 rtcp_receiver.SendRtcpFromRtpReceiver(NULL, NULL); | 436 rtcp_receiver.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_); |
495 rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 1); | 437 rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 1, 1, 1); |
496 RunTasks(33); | 438 RunTasks(33); |
497 | 439 |
498 EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); | 440 EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt)); |
499 EXPECT_NEAR(kAddedDelay + kAddedShortDelay, rtt.InMilliseconds(), 2); | 441 EXPECT_NEAR(kAddedDelay + kAddedShortDelay, rtt.InMilliseconds(), 2); |
500 } | 442 } |
501 | 443 |
502 TEST_F(RtcpTest, NtpAndTime) { | 444 TEST_F(RtcpTest, NtpAndTime) { |
503 const int64 kSecondsbetweenYear1900and2010 = INT64_C(40176 * 24 * 60 * 60); | 445 const int64 kSecondsbetweenYear1900and2010 = INT64_C(40176 * 24 * 60 * 60); |
504 const int64 kSecondsbetweenYear1900and2030 = INT64_C(47481 * 24 * 60 * 60); | 446 const int64 kSecondsbetweenYear1900and2030 = INT64_C(47481 * 24 * 60 * 60); |
505 | 447 |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
540 base::TimeTicks out_3 = ConvertNtpToTimeTicks(ntp_seconds_3, ntp_fraction_3); | 482 base::TimeTicks out_3 = ConvertNtpToTimeTicks(ntp_seconds_3, ntp_fraction_3); |
541 EXPECT_EQ(input_time, out_3); // Verify inverse. | 483 EXPECT_EQ(input_time, out_3); // Verify inverse. |
542 | 484 |
543 // Verify delta. | 485 // Verify delta. |
544 EXPECT_EQ((out_3 - out_2), time_delta); | 486 EXPECT_EQ((out_3 - out_2), time_delta); |
545 EXPECT_NEAR((ntp_fraction_3 - ntp_fraction_2), 0xffffffff / 2, 1); | 487 EXPECT_NEAR((ntp_fraction_3 - ntp_fraction_2), 0xffffffff / 2, 1); |
546 } | 488 } |
547 | 489 |
548 } // namespace cast | 490 } // namespace cast |
549 } // namespace media | 491 } // namespace media |
OLD | NEW |