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