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