src/media/cast/net/rtcp/rtcp_sender_unittest.cc

   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
   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_defines.h"
   8 #include "media/cast/cast_environment.h"
   9 #include "media/cast/net/cast_transport_defines.h"
  10 #include "media/cast/net/pacing/paced_sender.h"
  11 #include "media/cast/net/rtcp/receiver_rtcp_event_subscriber.h"
  12 #include "media/cast/net/rtcp/rtcp_sender.h"
  13 #include "media/cast/net/rtcp/rtcp_utility.h"
  14 #include "media/cast/net/rtcp/test_rtcp_packet_builder.h"
  15 #include "media/cast/test/fake_single_thread_task_runner.h"
  16 #include "testing/gmock/include/gmock/gmock.h"
  17
  18 namespace media {
  19 namespace cast {
  20
  21 namespace {
  22 static const uint32 kSendingSsrc = 0x12345678;
  23 static const uint32 kMediaSsrc = 0x87654321;
  24 static const base::TimeDelta kDefaultDelay =
  25     base::TimeDelta::FromMilliseconds(100);
  26
  27 RtcpReportBlock GetReportBlock() {
  28   RtcpReportBlock report_block;
  29   // Initialize remote_ssrc to a "clearly illegal" value.
  30   report_block.remote_ssrc = 0xDEAD;
  31   report_block.media_ssrc = kMediaSsrc;  // SSRC of the RTP packet sender.
  32   report_block.fraction_lost = kLoss >> 24;
  33   report_block.cumulative_lost = kLoss;  // 24 bits valid.
  34   report_block.extended_high_sequence_number = kExtendedMax;
  35   report_block.jitter = kTestJitter;
  36   report_block.last_sr = kLastSr;
  37   report_block.delay_since_last_sr = kDelayLastSr;
  38   return report_block;
  39 }
  40
  41 }  // namespace
  42
  43 class TestRtcpTransport : public PacedPacketSender {
  44  public:
  45   TestRtcpTransport() : packet_count_(0) {}
  46
  47   virtual bool SendRtcpPacket(uint32 ssrc,
  48                               PacketRef packet) OVERRIDE {
  49     EXPECT_EQ(expected_packet_.size(), packet->data.size());
  50     if (expected_packet_.size() != packet->data.size())
  51       return false;
  52     EXPECT_EQ(0, memcmp(&expected_packet_[0],
  53                         &packet->data[0],
  54                         packet->data.size()));
  55     packet_count_++;
  56     return true;
  57   }
  58
  59   virtual bool SendPackets(
  60       const SendPacketVector& packets) OVERRIDE {
  61     return false;
  62   }
  63   virtual bool ResendPackets(
  64       const SendPacketVector& packets,
  65       base::TimeDelta dedupe_window) OVERRIDE {
  66     return false;
  67   }
  68
  69   virtual void CancelSendingPacket(
  70       const PacketKey& packet_key) OVERRIDE {
  71   }
  72
  73   void SetExpectedRtcpPacket(scoped_ptr<Packet> packet) {
  74     expected_packet_.swap(*packet);
  75   }
  76
  77   int packet_count() const { return packet_count_; }
  78
  79  private:
  80   Packet expected_packet_;
  81   int packet_count_;
  82
  83   DISALLOW_COPY_AND_ASSIGN(TestRtcpTransport);
  84 };
  85
  86 class RtcpSenderTest : public ::testing::Test {
  87  protected:
  88   RtcpSenderTest()
  89       : testing_clock_(new base::SimpleTestTickClock()),
  90         task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)),
  91         cast_environment_(new CastEnvironment(
  92             scoped_ptr<base::TickClock>(testing_clock_).Pass(),
  93             task_runner_,
  94             task_runner_,
  95             task_runner_)),
  96         rtcp_sender_(new RtcpSender(&test_transport_, kSendingSsrc)) {}
  97
  98   base::SimpleTestTickClock* testing_clock_;  // Owned by CastEnvironment.
  99   TestRtcpTransport test_transport_;
 100   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
 101   scoped_refptr<CastEnvironment> cast_environment_;
 102   scoped_ptr<RtcpSender> rtcp_sender_;
 103
 104   DISALLOW_COPY_AND_ASSIGN(RtcpSenderTest);
 105 };
 106
 107 TEST_F(RtcpSenderTest, RtcpReceiverReport) {
 108   // Empty receiver report.
 109   TestRtcpPacketBuilder p1;
 110   p1.AddRr(kSendingSsrc, 0);
 111   test_transport_.SetExpectedRtcpPacket(p1.GetPacket());
 112
 113   rtcp_sender_->SendRtcpFromRtpReceiver(
 114       kRtcpRr, NULL, NULL, NULL, NULL, kDefaultDelay);
 115
 116   EXPECT_EQ(1, test_transport_.packet_count());
 117
 118   // Receiver report with report block.
 119   TestRtcpPacketBuilder p2;
 120   p2.AddRr(kSendingSsrc, 1);
 121   p2.AddRb(kMediaSsrc);
 122   test_transport_.SetExpectedRtcpPacket(p2.GetPacket().Pass());
 123
 124   RtcpReportBlock report_block = GetReportBlock();
 125
 126   rtcp_sender_->SendRtcpFromRtpReceiver(
 127       kRtcpRr, &report_block, NULL, NULL, NULL, kDefaultDelay);
 128
 129   EXPECT_EQ(2, test_transport_.packet_count());
 130 }
 131
 132 TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtr) {
 133   // Receiver report with report block.
 134   TestRtcpPacketBuilder p;
 135   p.AddRr(kSendingSsrc, 1);
 136   p.AddRb(kMediaSsrc);
 137   p.AddXrHeader(kSendingSsrc);
 138   p.AddXrRrtrBlock();
 139   test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 140
 141   RtcpReportBlock report_block = GetReportBlock();
 142
 143   RtcpReceiverReferenceTimeReport rrtr;
 144   rrtr.ntp_seconds = kNtpHigh;
 145   rrtr.ntp_fraction = kNtpLow;
 146
 147   rtcp_sender_->SendRtcpFromRtpReceiver(
 148       kRtcpRr | kRtcpRrtr,
 149       &report_block,
 150       &rrtr,
 151       NULL,
 152       NULL,
 153       kDefaultDelay);
 154
 155   EXPECT_EQ(1, test_transport_.packet_count());
 156 }
 157
 158 TEST_F(RtcpSenderTest, RtcpReceiverReportWithCast) {
 159   // Receiver report with report block.
 160   TestRtcpPacketBuilder p;
 161   p.AddRr(kSendingSsrc, 1);
 162   p.AddRb(kMediaSsrc);
 163   p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay);
 164   test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 165
 166   RtcpReportBlock report_block = GetReportBlock();
 167
 168   RtcpCastMessage cast_message(kMediaSsrc);
 169   cast_message.ack_frame_id = kAckFrameId;
 170   PacketIdSet missing_packets;
 171   cast_message.missing_frames_and_packets[kLostFrameId] = missing_packets;
 172
 173   missing_packets.insert(kLostPacketId1);
 174   missing_packets.insert(kLostPacketId2);
 175   missing_packets.insert(kLostPacketId3);
 176   cast_message.missing_frames_and_packets[kFrameIdWithLostPackets] =
 177       missing_packets;
 178
 179   rtcp_sender_->SendRtcpFromRtpReceiver(
 180       kRtcpRr | kRtcpCast,
 181       &report_block,
 182       NULL,
 183       &cast_message,
 184       NULL,
 185       kDefaultDelay);
 186
 187   EXPECT_EQ(1, test_transport_.packet_count());
 188 }
 189
 190 TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtraAndCastMessage) {
 191   TestRtcpPacketBuilder p;
 192   p.AddRr(kSendingSsrc, 1);
 193   p.AddRb(kMediaSsrc);
 194   p.AddXrHeader(kSendingSsrc);
 195   p.AddXrRrtrBlock();
 196   p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay);
 197   test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 198
 199   RtcpReportBlock report_block = GetReportBlock();
 200
 201   RtcpReceiverReferenceTimeReport rrtr;
 202   rrtr.ntp_seconds = kNtpHigh;
 203   rrtr.ntp_fraction = kNtpLow;
 204
 205   RtcpCastMessage cast_message(kMediaSsrc);
 206   cast_message.ack_frame_id = kAckFrameId;
 207   PacketIdSet missing_packets;
 208   cast_message.missing_frames_and_packets[kLostFrameId] = missing_packets;
 209
 210   missing_packets.insert(kLostPacketId1);
 211   missing_packets.insert(kLostPacketId2);
 212   missing_packets.insert(kLostPacketId3);
 213   cast_message.missing_frames_and_packets[kFrameIdWithLostPackets] =
 214       missing_packets;
 215
 216   rtcp_sender_->SendRtcpFromRtpReceiver(
 217       kRtcpRr | kRtcpRrtr | kRtcpCast,
 218       &report_block,
 219       &rrtr,
 220       &cast_message,
 221       NULL,
 222       kDefaultDelay);
 223
 224   EXPECT_EQ(1, test_transport_.packet_count());
 225 }
 226
 227 TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) {
 228   static const uint32 kTimeBaseMs = 12345678;
 229   static const uint32 kTimeDelayMs = 10;
 230
 231   TestRtcpPacketBuilder p;
 232   p.AddRr(kSendingSsrc, 1);
 233   p.AddRb(kMediaSsrc);
 234   p.AddXrHeader(kSendingSsrc);
 235   p.AddXrRrtrBlock();
 236   p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay);
 237   test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 238
 239   RtcpReportBlock report_block = GetReportBlock();
 240
 241   RtcpReceiverReferenceTimeReport rrtr;
 242   rrtr.ntp_seconds = kNtpHigh;
 243   rrtr.ntp_fraction = kNtpLow;
 244
 245   RtcpCastMessage cast_message(kMediaSsrc);
 246   cast_message.ack_frame_id = kAckFrameId;
 247   PacketIdSet missing_packets;
 248   cast_message.missing_frames_and_packets[kLostFrameId] = missing_packets;
 249
 250   missing_packets.insert(kLostPacketId1);
 251   missing_packets.insert(kLostPacketId2);
 252   missing_packets.insert(kLostPacketId3);
 253   cast_message.missing_frames_and_packets[kFrameIdWithLostPackets] =
 254       missing_packets;
 255
 256   ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
 257   ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
 258
 259   rtcp_sender_->SendRtcpFromRtpReceiver(
 260       kRtcpRr | kRtcpRrtr | kRtcpCast |
 261           kRtcpReceiverLog,
 262       &report_block,
 263       &rrtr,
 264       &cast_message,
 265       &rtcp_events,
 266       kDefaultDelay);
 267
 268   base::SimpleTestTickClock testing_clock;
 269   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 270
 271   p.AddReceiverLog(kSendingSsrc);
 272   p.AddReceiverFrameLog(kRtpTimestamp, 2, kTimeBaseMs);
 273   p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0);
 274   p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs);
 275
 276   test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 277
 278   FrameEvent frame_event;
 279   frame_event.rtp_timestamp = kRtpTimestamp;
 280   frame_event.type = FRAME_ACK_SENT;
 281   frame_event.media_type = VIDEO_EVENT;
 282   frame_event.timestamp = testing_clock.NowTicks();
 283   event_subscriber.OnReceiveFrameEvent(frame_event);
 284   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
 285
 286   PacketEvent packet_event;
 287   packet_event.rtp_timestamp = kRtpTimestamp;
 288   packet_event.type = PACKET_RECEIVED;
 289   packet_event.media_type = VIDEO_EVENT;
 290   packet_event.timestamp = testing_clock.NowTicks();
 291   packet_event.packet_id = kLostPacketId1;
 292   event_subscriber.OnReceivePacketEvent(packet_event);
 293   event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
 294   EXPECT_EQ(2u, rtcp_events.size());
 295
 296   rtcp_sender_->SendRtcpFromRtpReceiver(
 297       kRtcpRr | kRtcpRrtr | kRtcpCast |
 298           kRtcpReceiverLog,
 299       &report_block,
 300       &rrtr,
 301       &cast_message,
 302       &rtcp_events,
 303       kDefaultDelay);
 304
 305   EXPECT_EQ(2, test_transport_.packet_count());
 306 }
 307
 308 TEST_F(RtcpSenderTest, RtcpReceiverReportWithOversizedFrameLog) {
 309   static const uint32 kTimeBaseMs = 12345678;
 310   static const uint32 kTimeDelayMs = 10;
 311
 312   TestRtcpPacketBuilder p;
 313   p.AddRr(kSendingSsrc, 1);
 314   p.AddRb(kMediaSsrc);
 315
 316   RtcpReportBlock report_block = GetReportBlock();
 317
 318   base::SimpleTestTickClock testing_clock;
 319   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 320
 321   p.AddReceiverLog(kSendingSsrc);
 322
 323   int remaining_bytes = kMaxReceiverLogBytes;
 324   remaining_bytes -= kRtcpCastLogHeaderSize;
 325
 326   remaining_bytes -= kRtcpReceiverFrameLogSize;
 327   int num_events = remaining_bytes / kRtcpReceiverEventLogSize;
 328   EXPECT_LE(num_events, static_cast<int>(kRtcpMaxReceiverLogMessages));
 329   // Only the last |num_events| events are sent due to receiver log size cap.
 330   p.AddReceiverFrameLog(
 331       kRtpTimestamp + 2345,
 332       num_events,
 333       kTimeBaseMs + (kRtcpMaxReceiverLogMessages - num_events) * kTimeDelayMs);
 334   for (int i = 0; i < num_events; i++) {
 335     p.AddReceiverEventLog(
 336         kLostPacketId1, PACKET_RECEIVED,
 337         static_cast<uint16>(kTimeDelayMs * i));
 338   }
 339
 340   test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 341
 342   ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
 343   FrameEvent frame_event;
 344   frame_event.rtp_timestamp = kRtpTimestamp;
 345   frame_event.type = FRAME_ACK_SENT;
 346   frame_event.media_type = VIDEO_EVENT;
 347   frame_event.timestamp = testing_clock.NowTicks();
 348   event_subscriber.OnReceiveFrameEvent(frame_event);
 349
 350   for (size_t i = 0; i < kRtcpMaxReceiverLogMessages; ++i) {
 351     PacketEvent packet_event;
 352     packet_event.rtp_timestamp = kRtpTimestamp + 2345;
 353     packet_event.type = PACKET_RECEIVED;
 354     packet_event.media_type = VIDEO_EVENT;
 355     packet_event.timestamp = testing_clock.NowTicks();
 356     packet_event.packet_id = kLostPacketId1;
 357     event_subscriber.OnReceivePacketEvent(packet_event);
 358     testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
 359   }
 360
 361   ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
 362   event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
 363
 364   rtcp_sender_->SendRtcpFromRtpReceiver(
 365       kRtcpRr | kRtcpReceiverLog,
 366       &report_block,
 367       NULL,
 368       NULL,
 369       &rtcp_events,
 370       kDefaultDelay);
 371
 372   EXPECT_EQ(1, test_transport_.packet_count());
 373 }
 374
 375 TEST_F(RtcpSenderTest, RtcpReceiverReportWithTooManyLogFrames) {
 376   static const uint32 kTimeBaseMs = 12345678;
 377   static const uint32 kTimeDelayMs = 10;
 378
 379   TestRtcpPacketBuilder p;
 380   p.AddRr(kSendingSsrc, 1);
 381   p.AddRb(kMediaSsrc);
 382
 383   RtcpReportBlock report_block = GetReportBlock();
 384
 385   base::SimpleTestTickClock testing_clock;
 386   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 387
 388   p.AddReceiverLog(kSendingSsrc);
 389
 390   int remaining_bytes = kMaxReceiverLogBytes;
 391   remaining_bytes -= kRtcpCastLogHeaderSize;
 392
 393   int num_events =
 394       remaining_bytes / (kRtcpReceiverFrameLogSize + kRtcpReceiverEventLogSize);
 395
 396   // The last |num_events| events are sent due to receiver log size cap.
 397   for (size_t i = kRtcpMaxReceiverLogMessages - num_events;
 398        i < kRtcpMaxReceiverLogMessages;
 399        ++i) {
 400     p.AddReceiverFrameLog(kRtpTimestamp + i, 1, kTimeBaseMs + i * kTimeDelayMs);
 401     p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0);
 402   }
 403   test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 404
 405   ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
 406
 407   for (size_t i = 0; i < kRtcpMaxReceiverLogMessages; ++i) {
 408     FrameEvent frame_event;
 409     frame_event.rtp_timestamp = kRtpTimestamp + static_cast<int>(i);
 410     frame_event.type = FRAME_ACK_SENT;
 411     frame_event.media_type = VIDEO_EVENT;
 412     frame_event.timestamp = testing_clock.NowTicks();
 413     event_subscriber.OnReceiveFrameEvent(frame_event);
 414     testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
 415   }
 416
 417   ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
 418   event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
 419
 420   rtcp_sender_->SendRtcpFromRtpReceiver(
 421       kRtcpRr | kRtcpReceiverLog,
 422       &report_block,
 423       NULL,
 424       NULL,
 425       &rtcp_events,
 426       kDefaultDelay);
 427
 428   EXPECT_EQ(1, test_transport_.packet_count());
 429 }
 430
 431 TEST_F(RtcpSenderTest, RtcpReceiverReportWithOldLogFrames) {
 432   static const uint32 kTimeBaseMs = 12345678;
 433
 434   TestRtcpPacketBuilder p;
 435   p.AddRr(kSendingSsrc, 1);
 436   p.AddRb(kMediaSsrc);
 437
 438   RtcpReportBlock report_block = GetReportBlock();
 439
 440   base::SimpleTestTickClock testing_clock;
 441   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 442
 443   p.AddReceiverLog(kSendingSsrc);
 444
 445   // Log 11 events for a single frame, each |kTimeBetweenEventsMs| apart.
 446   // Only last 10 events will be sent because the first event is more than
 447   // 4095 milliseconds away from latest event.
 448   const int kTimeBetweenEventsMs = 410;
 449   p.AddReceiverFrameLog(kRtpTimestamp, 10, kTimeBaseMs + kTimeBetweenEventsMs);
 450   for (int i = 0; i < 10; ++i) {
 451     p.AddReceiverEventLog(0, FRAME_ACK_SENT, i * kTimeBetweenEventsMs);
 452   }
 453   test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 454
 455   ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
 456   for (int i = 0; i < 11; ++i) {
 457     FrameEvent frame_event;
 458     frame_event.rtp_timestamp = kRtpTimestamp;
 459     frame_event.type = FRAME_ACK_SENT;
 460     frame_event.media_type = VIDEO_EVENT;
 461     frame_event.timestamp = testing_clock.NowTicks();
 462     event_subscriber.OnReceiveFrameEvent(frame_event);
 463     testing_clock.Advance(
 464         base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs));
 465   }
 466
 467   ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
 468   event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
 469
 470   rtcp_sender_->SendRtcpFromRtpReceiver(
 471       kRtcpRr | kRtcpReceiverLog,
 472       &report_block,
 473       NULL,
 474       NULL,
 475       &rtcp_events,
 476       kDefaultDelay);
 477
 478   EXPECT_EQ(1, test_transport_.packet_count());
 479 }
 480
 481 TEST_F(RtcpSenderTest, RtcpReceiverReportRedundancy) {
 482   uint32 time_base_ms = 12345678;
 483   int kTimeBetweenEventsMs = 10;
 484
 485   RtcpReportBlock report_block = GetReportBlock();
 486
 487   base::SimpleTestTickClock testing_clock;
 488   testing_clock.Advance(base::TimeDelta::FromMilliseconds(time_base_ms));
 489
 490   ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT);
 491   size_t packet_count = kReceiveLogMessageHistorySize + 10;
 492   for (size_t i = 0; i < packet_count; i++) {
 493     TestRtcpPacketBuilder p;
 494     p.AddRr(kSendingSsrc, 1);
 495     p.AddRb(kMediaSsrc);
 496
 497     p.AddReceiverLog(kSendingSsrc);
 498
 499     if (i >= kSecondRedundancyOffset) {
 500       p.AddReceiverFrameLog(
 501           kRtpTimestamp,
 502           1,
 503           time_base_ms - kSecondRedundancyOffset * kTimeBetweenEventsMs);
 504       p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0);
 505     }
 506     if (i >= kFirstRedundancyOffset) {
 507       p.AddReceiverFrameLog(
 508           kRtpTimestamp,
 509           1,
 510           time_base_ms - kFirstRedundancyOffset * kTimeBetweenEventsMs);
 511       p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0);
 512     }
 513     p.AddReceiverFrameLog(kRtpTimestamp, 1, time_base_ms);
 514     p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0);
 515
 516     test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 517
 518     FrameEvent frame_event;
 519     frame_event.rtp_timestamp = kRtpTimestamp;
 520     frame_event.type = FRAME_ACK_SENT;
 521     frame_event.media_type = VIDEO_EVENT;
 522     frame_event.timestamp = testing_clock.NowTicks();
 523     event_subscriber.OnReceiveFrameEvent(frame_event);
 524
 525     ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
 526     event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
 527
 528     rtcp_sender_->SendRtcpFromRtpReceiver(
 529         kRtcpRr | kRtcpReceiverLog,
 530         &report_block,
 531         NULL,
 532         NULL,
 533         &rtcp_events,
 534         kDefaultDelay);
 535
 536     testing_clock.Advance(
 537         base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs));
 538     time_base_ms += kTimeBetweenEventsMs;
 539   }
 540
 541   EXPECT_EQ(static_cast<int>(packet_count), test_transport_.packet_count());
 542 }
 543
 544 TEST_F(RtcpSenderTest, RtcpSenderReport) {
 545   RtcpSenderInfo sender_info;
 546   sender_info.ntp_seconds = kNtpHigh;
 547   sender_info.ntp_fraction = kNtpLow;
 548   sender_info.rtp_timestamp = kRtpTimestamp;
 549   sender_info.send_packet_count = kSendPacketCount;
 550   sender_info.send_octet_count = kSendOctetCount;
 551
 552   RtcpDlrrReportBlock dlrr_rb;
 553   dlrr_rb.last_rr = kLastRr;
 554   dlrr_rb.delay_since_last_rr = kDelayLastRr;
 555
 556   // Sender report.
 557   TestRtcpPacketBuilder p;
 558   p.AddSr(kSendingSsrc, 0);
 559   test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 560
 561   rtcp_sender_->SendRtcpFromRtpSender(kRtcpSr,
 562                                       sender_info,
 563                                       dlrr_rb);
 564
 565   EXPECT_EQ(1, test_transport_.packet_count());
 566 }
 567
 568 TEST_F(RtcpSenderTest, RtcpSenderReportWithDlrr) {
 569   RtcpSenderInfo sender_info;
 570   sender_info.ntp_seconds = kNtpHigh;
 571   sender_info.ntp_fraction = kNtpLow;
 572   sender_info.rtp_timestamp = kRtpTimestamp;
 573   sender_info.send_packet_count = kSendPacketCount;
 574   sender_info.send_octet_count = kSendOctetCount;
 575
 576   // Sender report + dlrr.
 577   TestRtcpPacketBuilder p1;
 578   p1.AddSr(kSendingSsrc, 0);
 579   p1.AddXrHeader(kSendingSsrc);
 580   p1.AddXrDlrrBlock(kSendingSsrc);
 581   test_transport_.SetExpectedRtcpPacket(p1.GetPacket().Pass());
 582
 583   RtcpDlrrReportBlock dlrr_rb;
 584   dlrr_rb.last_rr = kLastRr;
 585   dlrr_rb.delay_since_last_rr = kDelayLastRr;
 586
 587   rtcp_sender_->SendRtcpFromRtpSender(
 588       kRtcpSr | kRtcpDlrr,
 589       sender_info,
 590       dlrr_rb);
 591
 592   EXPECT_EQ(1, test_transport_.packet_count());
 593 }
 594
 595 }  // namespace cast
 596 }  // namespace media