src/media/cast/rtcp/rtcp_sender_unittest.cc

   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_defines.h"
   8 #include "media/cast/cast_environment.h"
   9 #include "media/cast/rtcp/receiver_rtcp_event_subscriber.h"
  10 #include "media/cast/rtcp/rtcp_sender.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 "media/cast/transport/pacing/paced_sender.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 int16 kDefaultDelay = 100;
  25 static const std::string kCName("test@10.1.1.1");
  26
  27 transport::RtcpReportBlock GetReportBlock() {
  28   transport::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 transport::PacedPacketSender {
  44  public:
  45   TestRtcpTransport() : packet_count_(0) {}
  46
  47   virtual bool SendRtcpPacket(uint32 ssrc,
  48                               transport::PacketRef packet) OVERRIDE {
  49     EXPECT_EQ(expected_packet_.size(), packet->data.size());
  50     EXPECT_EQ(0, memcmp(expected_packet_.data(),
  51                         packet->data.data(),
  52                         packet->data.size()));
  53     packet_count_++;
  54     return true;
  55   }
  56
  57   virtual bool SendPackets(
  58       const transport::SendPacketVector& packets) OVERRIDE {
  59     return false;
  60   }
  61   virtual bool ResendPackets(
  62       const transport::SendPacketVector& packets) OVERRIDE {
  63     return false;
  64   }
  65
  66   void SetExpectedRtcpPacket(scoped_ptr<Packet> packet) {
  67     expected_packet_.swap(*packet);
  68   }
  69
  70   int packet_count() const { return packet_count_; }
  71
  72  private:
  73   Packet expected_packet_;
  74   int packet_count_;
  75
  76   DISALLOW_COPY_AND_ASSIGN(TestRtcpTransport);
  77 };
  78
  79 class RtcpSenderTest : public ::testing::Test {
  80  protected:
  81   RtcpSenderTest()
  82       : testing_clock_(new base::SimpleTestTickClock()),
  83         task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)),
  84         cast_environment_(new CastEnvironment(
  85             scoped_ptr<base::TickClock>(testing_clock_).Pass(),
  86             task_runner_,
  87             task_runner_,
  88             task_runner_)),
  89         rtcp_sender_(new RtcpSender(cast_environment_,
  90                                     &test_transport_,
  91                                     kSendingSsrc,
  92                                     kCName)) {}
  93
  94   base::SimpleTestTickClock* testing_clock_;  // Owned by CastEnvironment.
  95   TestRtcpTransport test_transport_;
  96   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
  97   scoped_refptr<CastEnvironment> cast_environment_;
  98   scoped_ptr<RtcpSender> rtcp_sender_;
  99
 100   DISALLOW_COPY_AND_ASSIGN(RtcpSenderTest);
 101 };
 102
 103 TEST_F(RtcpSenderTest, RtcpReceiverReport) {
 104   // Empty receiver report + c_name.
 105   TestRtcpPacketBuilder p1;
 106   p1.AddRr(kSendingSsrc, 0);
 107   p1.AddSdesCname(kSendingSsrc, kCName);
 108   test_transport_.SetExpectedRtcpPacket(p1.GetPacket());
 109
 110   rtcp_sender_->SendRtcpFromRtpReceiver(
 111       transport::kRtcpRr, NULL, NULL, NULL, NULL, kDefaultDelay);
 112
 113   EXPECT_EQ(1, test_transport_.packet_count());
 114
 115   // Receiver report with report block + c_name.
 116   TestRtcpPacketBuilder p2;
 117   p2.AddRr(kSendingSsrc, 1);
 118   p2.AddRb(kMediaSsrc);
 119   p2.AddSdesCname(kSendingSsrc, kCName);
 120   test_transport_.SetExpectedRtcpPacket(p2.GetPacket().Pass());
 121
 122   transport::RtcpReportBlock report_block = GetReportBlock();
 123
 124   rtcp_sender_->SendRtcpFromRtpReceiver(
 125       transport::kRtcpRr, &report_block, NULL, NULL, NULL, kDefaultDelay);
 126
 127   EXPECT_EQ(2, test_transport_.packet_count());
 128 }
 129
 130 TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtr) {
 131   // Receiver report with report block + c_name.
 132   TestRtcpPacketBuilder p;
 133   p.AddRr(kSendingSsrc, 1);
 134   p.AddRb(kMediaSsrc);
 135   p.AddSdesCname(kSendingSsrc, kCName);
 136   p.AddXrHeader(kSendingSsrc);
 137   p.AddXrRrtrBlock();
 138   test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 139
 140   transport::RtcpReportBlock report_block = GetReportBlock();
 141
 142   RtcpReceiverReferenceTimeReport rrtr;
 143   rrtr.ntp_seconds = kNtpHigh;
 144   rrtr.ntp_fraction = kNtpLow;
 145
 146   rtcp_sender_->SendRtcpFromRtpReceiver(
 147       transport::kRtcpRr | transport::kRtcpRrtr,
 148       &report_block,
 149       &rrtr,
 150       NULL,
 151       NULL,
 152       kDefaultDelay);
 153
 154   EXPECT_EQ(1, test_transport_.packet_count());
 155 }
 156
 157 TEST_F(RtcpSenderTest, RtcpReceiverReportWithCast) {
 158   // Receiver report with report block + c_name.
 159   TestRtcpPacketBuilder p;
 160   p.AddRr(kSendingSsrc, 1);
 161   p.AddRb(kMediaSsrc);
 162   p.AddSdesCname(kSendingSsrc, kCName);
 163   p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay);
 164   test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 165
 166   transport::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       transport::kRtcpRr | transport::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.AddSdesCname(kSendingSsrc, kCName);
 195   p.AddXrHeader(kSendingSsrc);
 196   p.AddXrRrtrBlock();
 197   p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay);
 198   test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 199
 200   transport::RtcpReportBlock report_block = GetReportBlock();
 201
 202   RtcpReceiverReferenceTimeReport rrtr;
 203   rrtr.ntp_seconds = kNtpHigh;
 204   rrtr.ntp_fraction = kNtpLow;
 205
 206   RtcpCastMessage cast_message(kMediaSsrc);
 207   cast_message.ack_frame_id_ = kAckFrameId;
 208   PacketIdSet missing_packets;
 209   cast_message.missing_frames_and_packets_[kLostFrameId] = missing_packets;
 210
 211   missing_packets.insert(kLostPacketId1);
 212   missing_packets.insert(kLostPacketId2);
 213   missing_packets.insert(kLostPacketId3);
 214   cast_message.missing_frames_and_packets_[kFrameIdWithLostPackets] =
 215       missing_packets;
 216
 217   rtcp_sender_->SendRtcpFromRtpReceiver(
 218       transport::kRtcpRr | transport::kRtcpRrtr | transport::kRtcpCast,
 219       &report_block,
 220       &rrtr,
 221       &cast_message,
 222       NULL,
 223       kDefaultDelay);
 224
 225   EXPECT_EQ(1, test_transport_.packet_count());
 226 }
 227
 228 TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) {
 229   static const uint32 kTimeBaseMs = 12345678;
 230   static const uint32 kTimeDelayMs = 10;
 231
 232   TestRtcpPacketBuilder p;
 233   p.AddRr(kSendingSsrc, 1);
 234   p.AddRb(kMediaSsrc);
 235   p.AddSdesCname(kSendingSsrc, kCName);
 236   p.AddXrHeader(kSendingSsrc);
 237   p.AddXrRrtrBlock();
 238   p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay);
 239   test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 240
 241   transport::RtcpReportBlock report_block = GetReportBlock();
 242
 243   RtcpReceiverReferenceTimeReport rrtr;
 244   rrtr.ntp_seconds = kNtpHigh;
 245   rrtr.ntp_fraction = kNtpLow;
 246
 247   RtcpCastMessage cast_message(kMediaSsrc);
 248   cast_message.ack_frame_id_ = kAckFrameId;
 249   PacketIdSet missing_packets;
 250   cast_message.missing_frames_and_packets_[kLostFrameId] = missing_packets;
 251
 252   missing_packets.insert(kLostPacketId1);
 253   missing_packets.insert(kLostPacketId2);
 254   missing_packets.insert(kLostPacketId3);
 255   cast_message.missing_frames_and_packets_[kFrameIdWithLostPackets] =
 256       missing_packets;
 257
 258   ReceiverRtcpEventSubscriber event_subscriber(
 259       500, ReceiverRtcpEventSubscriber::kVideoEventSubscriber);
 260   ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
 261
 262   rtcp_sender_->SendRtcpFromRtpReceiver(
 263       transport::kRtcpRr | transport::kRtcpRrtr | transport::kRtcpCast |
 264           transport::kRtcpReceiverLog,
 265       &report_block,
 266       &rrtr,
 267       &cast_message,
 268       &rtcp_events,
 269       kDefaultDelay);
 270
 271   base::SimpleTestTickClock testing_clock;
 272   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 273
 274   p.AddReceiverLog(kSendingSsrc);
 275   p.AddReceiverFrameLog(kRtpTimestamp, 2, kTimeBaseMs);
 276   p.AddReceiverEventLog(0, kVideoAckSent, 0);
 277   p.AddReceiverEventLog(kLostPacketId1, kVideoPacketReceived, kTimeDelayMs);
 278
 279   test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 280
 281   FrameEvent frame_event;
 282   frame_event.rtp_timestamp = kRtpTimestamp;
 283   frame_event.type = kVideoAckSent;
 284   frame_event.timestamp = testing_clock.NowTicks();
 285   event_subscriber.OnReceiveFrameEvent(frame_event);
 286   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
 287
 288   PacketEvent packet_event;
 289   packet_event.rtp_timestamp = kRtpTimestamp;
 290   packet_event.type = kVideoPacketReceived;
 291   packet_event.timestamp = testing_clock.NowTicks();
 292   packet_event.packet_id = kLostPacketId1;
 293   event_subscriber.OnReceivePacketEvent(packet_event);
 294   event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
 295   EXPECT_EQ(2u, rtcp_events.size());
 296
 297   rtcp_sender_->SendRtcpFromRtpReceiver(
 298       transport::kRtcpRr | transport::kRtcpRrtr | transport::kRtcpCast |
 299           transport::kRtcpReceiverLog,
 300       &report_block,
 301       &rrtr,
 302       &cast_message,
 303       &rtcp_events,
 304       kDefaultDelay);
 305
 306   EXPECT_EQ(2, test_transport_.packet_count());
 307 }
 308
 309 TEST_F(RtcpSenderTest, RtcpReceiverReportWithOversizedFrameLog) {
 310   static const uint32 kTimeBaseMs = 12345678;
 311   static const uint32 kTimeDelayMs = 10;
 312
 313   TestRtcpPacketBuilder p;
 314   p.AddRr(kSendingSsrc, 1);
 315   p.AddRb(kMediaSsrc);
 316   p.AddSdesCname(kSendingSsrc, kCName);
 317
 318   transport::RtcpReportBlock report_block = GetReportBlock();
 319
 320   base::SimpleTestTickClock testing_clock;
 321   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 322
 323   p.AddReceiverLog(kSendingSsrc);
 324
 325   int remaining_bytes = kMaxReceiverLogBytes;
 326   remaining_bytes -= kRtcpCastLogHeaderSize;
 327
 328   remaining_bytes -= kRtcpReceiverFrameLogSize;
 329   int num_events = remaining_bytes / kRtcpReceiverEventLogSize;
 330   EXPECT_LE(num_events, static_cast<int>(kRtcpMaxReceiverLogMessages));
 331   // Only the last |num_events| events are sent due to receiver log size cap.
 332   p.AddReceiverFrameLog(
 333       kRtpTimestamp + 2345,
 334       num_events,
 335       kTimeBaseMs + (kRtcpMaxReceiverLogMessages - num_events) * kTimeDelayMs);
 336   for (int i = 0; i < num_events; i++) {
 337     p.AddReceiverEventLog(
 338         kLostPacketId1, kVideoPacketReceived,
 339         static_cast<uint16>(kTimeDelayMs * i));
 340   }
 341
 342   test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 343
 344   ReceiverRtcpEventSubscriber event_subscriber(
 345       500, ReceiverRtcpEventSubscriber::kVideoEventSubscriber);
 346   FrameEvent frame_event;
 347   frame_event.rtp_timestamp = kRtpTimestamp;
 348   frame_event.type = media::cast::kVideoAckSent;
 349   frame_event.timestamp = testing_clock.NowTicks();
 350   event_subscriber.OnReceiveFrameEvent(frame_event);
 351
 352   for (size_t i = 0; i < kRtcpMaxReceiverLogMessages; ++i) {
 353     PacketEvent packet_event;
 354     packet_event.rtp_timestamp = kRtpTimestamp + 2345;
 355     packet_event.type = kVideoPacketReceived;
 356     packet_event.timestamp = testing_clock.NowTicks();
 357     packet_event.packet_id = kLostPacketId1;
 358     event_subscriber.OnReceivePacketEvent(packet_event);
 359     testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
 360   }
 361
 362   ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
 363   event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
 364
 365   rtcp_sender_->SendRtcpFromRtpReceiver(
 366       transport::kRtcpRr | transport::kRtcpReceiverLog,
 367       &report_block,
 368       NULL,
 369       NULL,
 370       &rtcp_events,
 371       kDefaultDelay);
 372
 373   EXPECT_EQ(1, test_transport_.packet_count());
 374 }
 375
 376 TEST_F(RtcpSenderTest, RtcpReceiverReportWithTooManyLogFrames) {
 377   static const uint32 kTimeBaseMs = 12345678;
 378   static const uint32 kTimeDelayMs = 10;
 379
 380   TestRtcpPacketBuilder p;
 381   p.AddRr(kSendingSsrc, 1);
 382   p.AddRb(kMediaSsrc);
 383   p.AddSdesCname(kSendingSsrc, kCName);
 384
 385   transport::RtcpReportBlock report_block = GetReportBlock();
 386
 387   base::SimpleTestTickClock testing_clock;
 388   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 389
 390   p.AddReceiverLog(kSendingSsrc);
 391
 392   int remaining_bytes = kMaxReceiverLogBytes;
 393   remaining_bytes -= kRtcpCastLogHeaderSize;
 394
 395   int num_events =
 396       remaining_bytes / (kRtcpReceiverFrameLogSize + kRtcpReceiverEventLogSize);
 397
 398   // The last |num_events| events are sent due to receiver log size cap.
 399   for (size_t i = kRtcpMaxReceiverLogMessages - num_events;
 400        i < kRtcpMaxReceiverLogMessages;
 401        ++i) {
 402     p.AddReceiverFrameLog(kRtpTimestamp + i, 1, kTimeBaseMs + i * kTimeDelayMs);
 403     p.AddReceiverEventLog(0, kVideoAckSent, 0);
 404   }
 405   test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 406
 407   ReceiverRtcpEventSubscriber event_subscriber(
 408       500, ReceiverRtcpEventSubscriber::kVideoEventSubscriber);
 409
 410   for (size_t i = 0; i < kRtcpMaxReceiverLogMessages; ++i) {
 411     FrameEvent frame_event;
 412     frame_event.rtp_timestamp = kRtpTimestamp + static_cast<int>(i);
 413     frame_event.type = media::cast::kVideoAckSent;
 414     frame_event.timestamp = testing_clock.NowTicks();
 415     event_subscriber.OnReceiveFrameEvent(frame_event);
 416     testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
 417   }
 418
 419   ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
 420   event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
 421
 422   rtcp_sender_->SendRtcpFromRtpReceiver(
 423       transport::kRtcpRr | transport::kRtcpReceiverLog,
 424       &report_block,
 425       NULL,
 426       NULL,
 427       &rtcp_events,
 428       kDefaultDelay);
 429
 430   EXPECT_EQ(1, test_transport_.packet_count());
 431 }
 432
 433 TEST_F(RtcpSenderTest, RtcpReceiverReportWithOldLogFrames) {
 434   static const uint32 kTimeBaseMs = 12345678;
 435
 436   TestRtcpPacketBuilder p;
 437   p.AddRr(kSendingSsrc, 1);
 438   p.AddRb(kMediaSsrc);
 439   p.AddSdesCname(kSendingSsrc, kCName);
 440
 441   transport::RtcpReportBlock report_block = GetReportBlock();
 442
 443   base::SimpleTestTickClock testing_clock;
 444   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 445
 446   p.AddReceiverLog(kSendingSsrc);
 447
 448   // Log 11 events for a single frame, each |kTimeBetweenEventsMs| apart.
 449   // Only last 10 events will be sent because the first event is more than
 450   // 4095 milliseconds away from latest event.
 451   const int kTimeBetweenEventsMs = 410;
 452   p.AddReceiverFrameLog(kRtpTimestamp, 10, kTimeBaseMs + kTimeBetweenEventsMs);
 453   for (int i = 0; i < 10; ++i) {
 454     p.AddReceiverEventLog(0, kVideoAckSent, i * kTimeBetweenEventsMs);
 455   }
 456   test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 457
 458   ReceiverRtcpEventSubscriber event_subscriber(
 459       500, ReceiverRtcpEventSubscriber::kVideoEventSubscriber);
 460   for (int i = 0; i < 11; ++i) {
 461     FrameEvent frame_event;
 462     frame_event.rtp_timestamp = kRtpTimestamp;
 463     frame_event.type = media::cast::kVideoAckSent;
 464     frame_event.timestamp = testing_clock.NowTicks();
 465     event_subscriber.OnReceiveFrameEvent(frame_event);
 466     testing_clock.Advance(
 467         base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs));
 468   }
 469
 470   ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
 471   event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
 472
 473   rtcp_sender_->SendRtcpFromRtpReceiver(
 474       transport::kRtcpRr | transport::kRtcpReceiverLog,
 475       &report_block,
 476       NULL,
 477       NULL,
 478       &rtcp_events,
 479       kDefaultDelay);
 480
 481   EXPECT_EQ(1, test_transport_.packet_count());
 482 }
 483
 484 TEST_F(RtcpSenderTest, RtcpReceiverReportRedundancy) {
 485   uint32 time_base_ms = 12345678;
 486   int kTimeBetweenEventsMs = 10;
 487
 488   transport::RtcpReportBlock report_block = GetReportBlock();
 489
 490   base::SimpleTestTickClock testing_clock;
 491   testing_clock.Advance(base::TimeDelta::FromMilliseconds(time_base_ms));
 492
 493   ReceiverRtcpEventSubscriber event_subscriber(
 494       500, ReceiverRtcpEventSubscriber::kVideoEventSubscriber);
 495   size_t packet_count = kReceiveLogMessageHistorySize + 10;
 496   for (size_t i = 0; i < packet_count; i++) {
 497     TestRtcpPacketBuilder p;
 498     p.AddRr(kSendingSsrc, 1);
 499     p.AddRb(kMediaSsrc);
 500     p.AddSdesCname(kSendingSsrc, kCName);
 501
 502     p.AddReceiverLog(kSendingSsrc);
 503
 504     if (i >= kSecondRedundancyOffset) {
 505       p.AddReceiverFrameLog(
 506           kRtpTimestamp,
 507           1,
 508           time_base_ms - kSecondRedundancyOffset * kTimeBetweenEventsMs);
 509       p.AddReceiverEventLog(0, kVideoAckSent, 0);
 510     }
 511     if (i >= kFirstRedundancyOffset) {
 512       p.AddReceiverFrameLog(
 513           kRtpTimestamp,
 514           1,
 515           time_base_ms - kFirstRedundancyOffset * kTimeBetweenEventsMs);
 516       p.AddReceiverEventLog(0, kVideoAckSent, 0);
 517     }
 518     p.AddReceiverFrameLog(kRtpTimestamp, 1, time_base_ms);
 519     p.AddReceiverEventLog(0, kVideoAckSent, 0);
 520
 521     test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass());
 522
 523     FrameEvent frame_event;
 524     frame_event.rtp_timestamp = kRtpTimestamp;
 525     frame_event.type = media::cast::kVideoAckSent;
 526     frame_event.timestamp = testing_clock.NowTicks();
 527     event_subscriber.OnReceiveFrameEvent(frame_event);
 528
 529     ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events;
 530     event_subscriber.GetRtcpEventsAndReset(&rtcp_events);
 531
 532     rtcp_sender_->SendRtcpFromRtpReceiver(
 533         transport::kRtcpRr | transport::kRtcpReceiverLog,
 534         &report_block,
 535         NULL,
 536         NULL,
 537         &rtcp_events,
 538         kDefaultDelay);
 539
 540     testing_clock.Advance(
 541         base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs));
 542     time_base_ms += kTimeBetweenEventsMs;
 543   }
 544
 545   EXPECT_EQ(static_cast<int>(packet_count), test_transport_.packet_count());
 546 }
 547
 548 }  // namespace cast
 549 }  // namespace media