src/third_party/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc

   1 /*
   2  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include "testing/gmock/include/gmock/gmock.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 #include "webrtc/common_types.h"
  15 #include "webrtc/modules/pacing/include/mock/mock_paced_sender.h"
  16 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
  17 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
  18 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
  19 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h"
  20 #include "webrtc/system_wrappers/interface/scoped_vector.h"
  21
  22 using ::testing::_;
  23 using ::testing::NiceMock;
  24 using ::testing::Return;
  25 using ::testing::SaveArg;
  26
  27 namespace webrtc {
  28 namespace {
  29 const uint32_t kSenderSsrc = 0x12345;
  30 const uint32_t kReceiverSsrc = 0x23456;
  31 const uint32_t kSenderRtxSsrc = 0x32345;
  32 const uint32_t kOneWayNetworkDelayMs = 100;
  33 const uint8_t kBaseLayerTid = 0;
  34 const uint8_t kHigherLayerTid = 1;
  35 const uint16_t kSequenceNumber = 100;
  36
  37 class RtcpRttStatsTestImpl : public RtcpRttStats {
  38  public:
  39   RtcpRttStatsTestImpl() : rtt_ms_(0) {}
  40   virtual ~RtcpRttStatsTestImpl() {}
  41
  42   virtual void OnRttUpdate(uint32_t rtt_ms) {
  43     rtt_ms_ = rtt_ms;
  44   }
  45   virtual uint32_t LastProcessedRtt() const {
  46     return rtt_ms_;
  47   }
  48   uint32_t rtt_ms_;
  49 };
  50
  51 class SendTransport : public Transport,
  52                       public NullRtpData {
  53  public:
  54   SendTransport()
  55       : receiver_(NULL),
  56         clock_(NULL),
  57         delay_ms_(0),
  58         rtp_packets_sent_(0) {
  59   }
  60
  61   void SetRtpRtcpModule(ModuleRtpRtcpImpl* receiver) {
  62     receiver_ = receiver;
  63   }
  64   void SimulateNetworkDelay(uint32_t delay_ms, SimulatedClock* clock) {
  65     clock_ = clock;
  66     delay_ms_ = delay_ms;
  67   }
  68   virtual int SendPacket(int /*ch*/, const void* data, int len) {
  69     RTPHeader header;
  70     scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
  71     EXPECT_TRUE(parser->Parse(static_cast<const uint8_t*>(data),
  72                               static_cast<size_t>(len),
  73                               &header));
  74     ++rtp_packets_sent_;
  75     last_rtp_header_ = header;
  76     return len;
  77   }
  78   virtual int SendRTCPPacket(int /*ch*/, const void *data, int len) {
  79     if (clock_) {
  80       clock_->AdvanceTimeMilliseconds(delay_ms_);
  81     }
  82     EXPECT_TRUE(receiver_ != NULL);
  83     EXPECT_EQ(0, receiver_->IncomingRtcpPacket(
  84         static_cast<const uint8_t*>(data), len));
  85     return len;
  86   }
  87   ModuleRtpRtcpImpl* receiver_;
  88   SimulatedClock* clock_;
  89   uint32_t delay_ms_;
  90   int rtp_packets_sent_;
  91   RTPHeader last_rtp_header_;
  92 };
  93
  94 class RtpRtcpModule {
  95  public:
  96   RtpRtcpModule(SimulatedClock* clock)
  97       : receive_statistics_(ReceiveStatistics::Create(clock)) {
  98     RtpRtcp::Configuration config;
  99     config.audio = false;
 100     config.clock = clock;
 101     config.outgoing_transport = &transport_;
 102     config.receive_statistics = receive_statistics_.get();
 103     config.rtt_stats = &rtt_stats_;
 104
 105     impl_.reset(new ModuleRtpRtcpImpl(config));
 106     EXPECT_EQ(0, impl_->SetRTCPStatus(kRtcpCompound));
 107
 108     transport_.SimulateNetworkDelay(kOneWayNetworkDelayMs, clock);
 109   }
 110
 111   RtcpPacketTypeCounter packets_sent_;
 112   RtcpPacketTypeCounter packets_received_;
 113   scoped_ptr<ReceiveStatistics> receive_statistics_;
 114   SendTransport transport_;
 115   RtcpRttStatsTestImpl rtt_stats_;
 116   scoped_ptr<ModuleRtpRtcpImpl> impl_;
 117
 118   RtcpPacketTypeCounter RtcpSent() {
 119     impl_->GetRtcpPacketTypeCounters(&packets_sent_, &packets_received_);
 120     return packets_sent_;
 121   }
 122   RtcpPacketTypeCounter RtcpReceived() {
 123     impl_->GetRtcpPacketTypeCounters(&packets_sent_, &packets_received_);
 124     return packets_received_;
 125   }
 126   int RtpSent() {
 127     return transport_.rtp_packets_sent_;
 128   }
 129   uint16_t LastRtpSequenceNumber() {
 130     return transport_.last_rtp_header_.sequenceNumber;
 131   }
 132 };
 133 }  // namespace
 134
 135 class RtpRtcpImplTest : public ::testing::Test {
 136  protected:
 137   RtpRtcpImplTest()
 138       : clock_(1335900000),
 139         sender_(&clock_),
 140         receiver_(&clock_) {
 141     // Send module.
 142     EXPECT_EQ(0, sender_.impl_->SetSendingStatus(true));
 143     EXPECT_EQ(0, sender_.impl_->SetSendingMediaStatus(true));
 144     sender_.impl_->SetSSRC(kSenderSsrc);
 145     sender_.impl_->SetRemoteSSRC(kReceiverSsrc);
 146     sender_.impl_->SetSequenceNumber(kSequenceNumber);
 147     sender_.impl_->SetStorePacketsStatus(true, 100);
 148
 149     memset(&codec_, 0, sizeof(VideoCodec));
 150     codec_.plType = 100;
 151     strncpy(codec_.plName, "VP8", 3);
 152     codec_.width = 320;
 153     codec_.height = 180;
 154     EXPECT_EQ(0, sender_.impl_->RegisterSendPayload(codec_));
 155
 156     // Receive module.
 157     EXPECT_EQ(0, receiver_.impl_->SetSendingStatus(false));
 158     EXPECT_EQ(0, receiver_.impl_->SetSendingMediaStatus(false));
 159     receiver_.impl_->SetSSRC(kReceiverSsrc);
 160     receiver_.impl_->SetRemoteSSRC(kSenderSsrc);
 161     // Transport settings.
 162     sender_.transport_.SetRtpRtcpModule(receiver_.impl_.get());
 163     receiver_.transport_.SetRtpRtcpModule(sender_.impl_.get());
 164   }
 165   SimulatedClock clock_;
 166   RtpRtcpModule sender_;
 167   RtpRtcpModule receiver_;
 168   VideoCodec codec_;
 169
 170   void SendFrame(const RtpRtcpModule* module, uint8_t tid) {
 171     RTPVideoHeaderVP8 vp8_header = {};
 172     vp8_header.temporalIdx = tid;
 173     RTPVideoHeader rtp_video_header = {
 174         codec_.width, codec_.height, true, 0, kRtpVideoVp8, {vp8_header}};
 175
 176     const uint8_t payload[100] = {0};
 177     EXPECT_EQ(0, module->impl_->SendOutgoingData(kVideoFrameKey,
 178                                                  codec_.plType,
 179                                                  0,
 180                                                  0,
 181                                                  payload,
 182                                                  sizeof(payload),
 183                                                  NULL,
 184                                                  &rtp_video_header));
 185   }
 186
 187   void IncomingRtcpNack(const RtpRtcpModule* module, uint16_t sequence_number) {
 188     rtcp::Nack nack;
 189     uint16_t list[1];
 190     list[0] = sequence_number;
 191     const uint16_t kListLength = sizeof(list) / sizeof(list[0]);
 192     nack.From(kReceiverSsrc);
 193     nack.To(kSenderSsrc);
 194     nack.WithList(list, kListLength);
 195     rtcp::RawPacket packet = nack.Build();
 196     EXPECT_EQ(0, module->impl_->IncomingRtcpPacket(packet.buffer(),
 197                                                    packet.buffer_length()));
 198   }
 199 };
 200
 201 TEST_F(RtpRtcpImplTest, SetSelectiveRetransmissions_BaseLayer) {
 202   sender_.impl_->SetSelectiveRetransmissions(kRetransmitBaseLayer);
 203   EXPECT_EQ(kRetransmitBaseLayer, sender_.impl_->SelectiveRetransmissions());
 204
 205   // Send frames.
 206   EXPECT_EQ(0, sender_.RtpSent());
 207   SendFrame(&sender_, kBaseLayerTid);    // kSequenceNumber
 208   SendFrame(&sender_, kHigherLayerTid);  // kSequenceNumber + 1
 209   SendFrame(&sender_, kNoTemporalIdx);   // kSequenceNumber + 2
 210   EXPECT_EQ(3, sender_.RtpSent());
 211   EXPECT_EQ(kSequenceNumber + 2, sender_.LastRtpSequenceNumber());
 212
 213   // Frame with kBaseLayerTid re-sent.
 214   IncomingRtcpNack(&sender_, kSequenceNumber);
 215   EXPECT_EQ(4, sender_.RtpSent());
 216   EXPECT_EQ(kSequenceNumber, sender_.LastRtpSequenceNumber());
 217   // Frame with kHigherLayerTid not re-sent.
 218   IncomingRtcpNack(&sender_, kSequenceNumber + 1);
 219   EXPECT_EQ(4, sender_.RtpSent());
 220   // Frame with kNoTemporalIdx re-sent.
 221   IncomingRtcpNack(&sender_, kSequenceNumber + 2);
 222   EXPECT_EQ(5, sender_.RtpSent());
 223   EXPECT_EQ(kSequenceNumber + 2, sender_.LastRtpSequenceNumber());
 224 }
 225
 226 TEST_F(RtpRtcpImplTest, SetSelectiveRetransmissions_HigherLayers) {
 227   const uint8_t kSetting = kRetransmitBaseLayer + kRetransmitHigherLayers;
 228   sender_.impl_->SetSelectiveRetransmissions(kSetting);
 229   EXPECT_EQ(kSetting, sender_.impl_->SelectiveRetransmissions());
 230
 231   // Send frames.
 232   EXPECT_EQ(0, sender_.RtpSent());
 233   SendFrame(&sender_, kBaseLayerTid);    // kSequenceNumber
 234   SendFrame(&sender_, kHigherLayerTid);  // kSequenceNumber + 1
 235   SendFrame(&sender_, kNoTemporalIdx);   // kSequenceNumber + 2
 236   EXPECT_EQ(3, sender_.RtpSent());
 237   EXPECT_EQ(kSequenceNumber + 2, sender_.LastRtpSequenceNumber());
 238
 239   // Frame with kBaseLayerTid re-sent.
 240   IncomingRtcpNack(&sender_, kSequenceNumber);
 241   EXPECT_EQ(4, sender_.RtpSent());
 242   EXPECT_EQ(kSequenceNumber, sender_.LastRtpSequenceNumber());
 243   // Frame with kHigherLayerTid re-sent.
 244   IncomingRtcpNack(&sender_, kSequenceNumber + 1);
 245   EXPECT_EQ(5, sender_.RtpSent());
 246   EXPECT_EQ(kSequenceNumber + 1, sender_.LastRtpSequenceNumber());
 247   // Frame with kNoTemporalIdx re-sent.
 248   IncomingRtcpNack(&sender_, kSequenceNumber + 2);
 249   EXPECT_EQ(6, sender_.RtpSent());
 250   EXPECT_EQ(kSequenceNumber + 2, sender_.LastRtpSequenceNumber());
 251 }
 252
 253 TEST_F(RtpRtcpImplTest, Rtt) {
 254   RTPHeader header;
 255   header.timestamp = 1;
 256   header.sequenceNumber = 123;
 257   header.ssrc = kSenderSsrc;
 258   header.headerLength = 12;
 259   receiver_.receive_statistics_->IncomingPacket(header, 100, false);
 260
 261   // Sender module should send a SR.
 262   EXPECT_EQ(0, sender_.impl_->SendRTCP(kRtcpReport));
 263
 264   // Receiver module should send a RR with a response to the last received SR.
 265   clock_.AdvanceTimeMilliseconds(1000);
 266   EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpReport));
 267
 268   // Verify RTT.
 269   uint16_t rtt;
 270   uint16_t avg_rtt;
 271   uint16_t min_rtt;
 272   uint16_t max_rtt;
 273   EXPECT_EQ(0,
 274       sender_.impl_->RTT(kReceiverSsrc, &rtt, &avg_rtt, &min_rtt, &max_rtt));
 275   EXPECT_EQ(2 * kOneWayNetworkDelayMs, rtt);
 276   EXPECT_EQ(2 * kOneWayNetworkDelayMs, avg_rtt);
 277   EXPECT_EQ(2 * kOneWayNetworkDelayMs, min_rtt);
 278   EXPECT_EQ(2 * kOneWayNetworkDelayMs, max_rtt);
 279
 280   // No RTT from other ssrc.
 281   EXPECT_EQ(-1,
 282       sender_.impl_->RTT(kReceiverSsrc+1, &rtt, &avg_rtt, &min_rtt, &max_rtt));
 283
 284   // Verify RTT from rtt_stats config.
 285   EXPECT_EQ(0U, sender_.rtt_stats_.LastProcessedRtt());
 286   EXPECT_EQ(0U, sender_.impl_->rtt_ms());
 287   sender_.impl_->Process();
 288   EXPECT_EQ(2 * kOneWayNetworkDelayMs, sender_.rtt_stats_.LastProcessedRtt());
 289   EXPECT_EQ(2 * kOneWayNetworkDelayMs, sender_.impl_->rtt_ms());
 290 }
 291
 292 TEST_F(RtpRtcpImplTest, SetRtcpXrRrtrStatus) {
 293   EXPECT_FALSE(receiver_.impl_->RtcpXrRrtrStatus());
 294   receiver_.impl_->SetRtcpXrRrtrStatus(true);
 295   EXPECT_TRUE(receiver_.impl_->RtcpXrRrtrStatus());
 296 }
 297
 298 TEST_F(RtpRtcpImplTest, RttForReceiverOnly) {
 299   receiver_.impl_->SetRtcpXrRrtrStatus(true);
 300
 301   // Receiver module should send a Receiver time reference report (RTRR).
 302   EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpReport));
 303
 304   // Sender module should send a response to the last received RTRR (DLRR).
 305   clock_.AdvanceTimeMilliseconds(1000);
 306   EXPECT_EQ(0, sender_.impl_->SendRTCP(kRtcpReport));
 307
 308   // Verify RTT.
 309   EXPECT_EQ(0U, receiver_.rtt_stats_.LastProcessedRtt());
 310   EXPECT_EQ(0U, receiver_.impl_->rtt_ms());
 311   receiver_.impl_->Process();
 312   EXPECT_EQ(2 * kOneWayNetworkDelayMs, receiver_.rtt_stats_.LastProcessedRtt());
 313   EXPECT_EQ(2 * kOneWayNetworkDelayMs, receiver_.impl_->rtt_ms());
 314 }
 315
 316 TEST_F(RtpRtcpImplTest, RtcpPacketTypeCounter_Nack) {
 317   EXPECT_EQ(0U, sender_.RtcpReceived().nack_packets);
 318   EXPECT_EQ(0U, receiver_.RtcpSent().nack_packets);
 319   // Receive module sends a NACK.
 320   const uint16_t kNackLength = 1;
 321   uint16_t nack_list[kNackLength] = {123};
 322   EXPECT_EQ(0, receiver_.impl_->SendNACK(nack_list, kNackLength));
 323   EXPECT_EQ(1U, receiver_.RtcpSent().nack_packets);
 324
 325   // Send module receives the NACK.
 326   EXPECT_EQ(1U, sender_.RtcpReceived().nack_packets);
 327 }
 328
 329 TEST_F(RtpRtcpImplTest, RtcpPacketTypeCounter_FirAndPli) {
 330   EXPECT_EQ(0U, sender_.RtcpReceived().fir_packets);
 331   EXPECT_EQ(0U, receiver_.RtcpSent().fir_packets);
 332   // Receive module sends a FIR.
 333   EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpFir));
 334   EXPECT_EQ(1U, receiver_.RtcpSent().fir_packets);
 335   // Send module receives the FIR.
 336   EXPECT_EQ(1U, sender_.RtcpReceived().fir_packets);
 337
 338   // Receive module sends a FIR and PLI.
 339   EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpFir | kRtcpPli));
 340   EXPECT_EQ(2U, receiver_.RtcpSent().fir_packets);
 341   EXPECT_EQ(1U, receiver_.RtcpSent().pli_packets);
 342   // Send module receives the FIR and PLI.
 343   EXPECT_EQ(2U, sender_.RtcpReceived().fir_packets);
 344   EXPECT_EQ(1U, sender_.RtcpReceived().pli_packets);
 345 }
 346
 347 class RtpSendingTestTransport : public Transport {
 348  public:
 349   void ResetCounters() { bytes_received_.clear(); }
 350
 351   virtual int SendPacket(int channel, const void* data, int length) {
 352     RTPHeader header;
 353     scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
 354     EXPECT_TRUE(parser->Parse(static_cast<const uint8_t*>(data),
 355                               static_cast<size_t>(length),
 356                               &header));
 357     bytes_received_[header.ssrc] += length;
 358     ++packets_received_[header.ssrc];
 359     return length;
 360   }
 361
 362   virtual int SendRTCPPacket(int channel, const void* data, int length) {
 363     return length;
 364   }
 365
 366   int GetPacketsReceived(uint32_t ssrc) const {
 367     std::map<uint32_t, int>::const_iterator it = packets_received_.find(ssrc);
 368     if (it == packets_received_.end())
 369       return 0;
 370     return it->second;
 371   }
 372
 373   int GetBytesReceived(uint32_t ssrc) const {
 374     std::map<uint32_t, int>::const_iterator it = bytes_received_.find(ssrc);
 375     if (it == bytes_received_.end())
 376       return 0;
 377     return it->second;
 378   }
 379
 380   int GetTotalBytesReceived() const {
 381     int sum = 0;
 382     for (std::map<uint32_t, int>::const_iterator it = bytes_received_.begin();
 383          it != bytes_received_.end();
 384          ++it) {
 385       sum += it->second;
 386     }
 387     return sum;
 388   }
 389
 390  private:
 391   std::map<uint32_t, int> bytes_received_;
 392   std::map<uint32_t, int> packets_received_;
 393 };
 394
 395 class RtpSendingTest : public ::testing::Test {
 396  protected:
 397   // Map from SSRC to number of received packets and bytes.
 398   typedef std::map<uint32_t, std::pair<int, int> > PaddingMap;
 399
 400   RtpSendingTest() {
 401     // Send module.
 402     RtpRtcp::Configuration config;
 403     config.audio = false;
 404     config.clock = Clock::GetRealTimeClock();
 405     config.outgoing_transport = &transport_;
 406     config.receive_statistics = receive_statistics_.get();
 407     config.rtt_stats = &rtt_stats_;
 408     config.paced_sender = &pacer_;
 409     memset(&codec_, 0, sizeof(VideoCodec));
 410     codec_.plType = 100;
 411     strncpy(codec_.plName, "VP8", 3);
 412     codec_.numberOfSimulcastStreams = 3;
 413     codec_.simulcastStream[0].width = 320;
 414     codec_.simulcastStream[0].height = 180;
 415     codec_.simulcastStream[0].maxBitrate = 300;
 416     codec_.simulcastStream[1].width = 640;
 417     codec_.simulcastStream[1].height = 360;
 418     codec_.simulcastStream[1].maxBitrate = 600;
 419     codec_.simulcastStream[2].width = 1280;
 420     codec_.simulcastStream[2].height = 720;
 421     codec_.simulcastStream[2].maxBitrate = 1200;
 422     // We need numberOfSimulcastStreams + 1 RTP modules since we need one
 423     // default module.
 424     for (int i = 0; i < codec_.numberOfSimulcastStreams + 1; ++i) {
 425       RtpRtcp* sender = RtpRtcp::CreateRtpRtcp(config);
 426       EXPECT_EQ(0, sender->RegisterSendPayload(codec_));
 427       EXPECT_EQ(0, sender->SetSendingStatus(true));
 428       EXPECT_EQ(0, sender->SetSendingMediaStatus(true));
 429       sender->SetSSRC(kSenderSsrc + i);
 430       sender->SetRemoteSSRC(kReceiverSsrc + i);
 431       senders_.push_back(sender);
 432       config.default_module = senders_[0];
 433     }
 434     std::vector<uint32_t> bitrates;
 435     bitrates.push_back(codec_.simulcastStream[0].maxBitrate);
 436     bitrates.push_back(codec_.simulcastStream[1].maxBitrate);
 437     bitrates.push_back(codec_.simulcastStream[2].maxBitrate);
 438     senders_[0]->SetTargetSendBitrate(bitrates);
 439   }
 440
 441   ~RtpSendingTest() {
 442     for (int i = senders_.size() - 1; i >= 0; --i) {
 443       delete senders_[i];
 444     }
 445   }
 446
 447   void SendFrameOnSender(int sender_index,
 448                          const uint8_t* payload,
 449                          size_t length) {
 450     RTPVideoHeader rtp_video_header = {
 451         codec_.simulcastStream[sender_index].width,
 452         codec_.simulcastStream[sender_index].height,
 453         true,
 454         0,
 455         kRtpVideoVp8,
 456         {}};
 457     uint32_t seq_num = 0;
 458     uint32_t ssrc = 0;
 459     int64_t capture_time_ms = 0;
 460     bool retransmission = false;
 461     EXPECT_CALL(pacer_, SendPacket(_, _, _, _, _, _))
 462         .WillRepeatedly(DoAll(SaveArg<1>(&ssrc),
 463                               SaveArg<2>(&seq_num),
 464                               SaveArg<3>(&capture_time_ms),
 465                               SaveArg<5>(&retransmission),
 466                               Return(true)));
 467     EXPECT_EQ(0,
 468               senders_[sender_index]->SendOutgoingData(kVideoFrameKey,
 469                                                        codec_.plType,
 470                                                        0,
 471                                                        0,
 472                                                        payload,
 473                                                        length,
 474                                                        NULL,
 475                                                        &rtp_video_header));
 476     EXPECT_TRUE(senders_[sender_index]->TimeToSendPacket(
 477         ssrc, seq_num, capture_time_ms, retransmission));
 478   }
 479
 480   void ExpectPadding(const PaddingMap& expected_padding) {
 481     int expected_total_bytes = 0;
 482     for (PaddingMap::const_iterator it = expected_padding.begin();
 483          it != expected_padding.end();
 484          ++it) {
 485       int packets_received = transport_.GetBytesReceived(it->first);
 486       if (it->second.first > 0) {
 487         EXPECT_GE(packets_received, it->second.first)
 488             << "On SSRC: " << it->first;
 489       }
 490       int bytes_received = transport_.GetBytesReceived(it->first);
 491       expected_total_bytes += bytes_received;
 492       if (it->second.second > 0) {
 493         EXPECT_GE(bytes_received, it->second.second)
 494             << "On SSRC: " << it->first;
 495       } else {
 496         EXPECT_EQ(0, bytes_received) << "On SSRC: " << it->first;
 497       }
 498     }
 499     EXPECT_EQ(expected_total_bytes, transport_.GetTotalBytesReceived());
 500   }
 501
 502   scoped_ptr<ReceiveStatistics> receive_statistics_;
 503   RtcpRttStatsTestImpl rtt_stats_;
 504   std::vector<RtpRtcp*> senders_;
 505   RtpSendingTestTransport transport_;
 506   NiceMock<MockPacedSender> pacer_;
 507   VideoCodec codec_;
 508 };
 509
 510 TEST_F(RtpSendingTest, DISABLED_RoundRobinPadding) {
 511   // We have to send on an SSRC to be allowed to pad, since a marker bit must
 512   // be sent prior to padding packets.
 513   const uint8_t payload[200] = {0};
 514   for (int i = 0; i < codec_.numberOfSimulcastStreams; ++i) {
 515     SendFrameOnSender(i + 1, payload, sizeof(payload));
 516   }
 517   transport_.ResetCounters();
 518   senders_[0]->TimeToSendPadding(500);
 519   PaddingMap expected_padding;
 520   expected_padding[kSenderSsrc + 1] = std::make_pair(2, 500);
 521   expected_padding[kSenderSsrc + 2] = std::make_pair(0, 0);
 522   expected_padding[kSenderSsrc + 3] = std::make_pair(0, 0);
 523   ExpectPadding(expected_padding);
 524   senders_[0]->TimeToSendPadding(1000);
 525   expected_padding[kSenderSsrc + 2] = std::make_pair(4, 1000);
 526   ExpectPadding(expected_padding);
 527   senders_[0]->TimeToSendPadding(1500);
 528   expected_padding[kSenderSsrc + 3] = std::make_pair(6, 1500);
 529   ExpectPadding(expected_padding);
 530 }
 531
 532 TEST_F(RtpSendingTest, DISABLED_RoundRobinPaddingRtx) {
 533   // Enable RTX to allow padding to be sent prior to media.
 534   for (int i = 1; i < codec_.numberOfSimulcastStreams + 1; ++i) {
 535     // Abs-send-time is needed to be allowed to send padding prior to media,
 536     // as otherwise the timestmap used for BWE will be broken.
 537     senders_[i]->RegisterSendRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
 538                                                 1);
 539     senders_[i]->SetRtxSendPayloadType(96);
 540     senders_[i]->SetRtxSsrc(kSenderRtxSsrc + i);
 541     senders_[i]->SetRTXSendStatus(kRtxRetransmitted);
 542   }
 543   transport_.ResetCounters();
 544   senders_[0]->TimeToSendPadding(500);
 545   PaddingMap expected_padding;
 546   expected_padding[kSenderSsrc + 1] = std::make_pair(0, 0);
 547   expected_padding[kSenderSsrc + 2] = std::make_pair(0, 0);
 548   expected_padding[kSenderSsrc + 3] = std::make_pair(0, 0);
 549   expected_padding[kSenderRtxSsrc + 1] = std::make_pair(2, 500);
 550   expected_padding[kSenderRtxSsrc + 2] = std::make_pair(0, 0);
 551   expected_padding[kSenderRtxSsrc + 3] = std::make_pair(0, 0);
 552   ExpectPadding(expected_padding);
 553   senders_[0]->TimeToSendPadding(1000);
 554   expected_padding[kSenderRtxSsrc + 2] = std::make_pair(4, 500);
 555   ExpectPadding(expected_padding);
 556   senders_[0]->TimeToSendPadding(1500);
 557
 558   expected_padding[kSenderRtxSsrc + 3] = std::make_pair(6, 500);
 559   ExpectPadding(expected_padding);
 560 }
 561
 562 TEST_F(RtpSendingTest, DISABLED_RoundRobinPaddingRtxRedundantPayloads) {
 563   for (int i = 1; i < codec_.numberOfSimulcastStreams + 1; ++i) {
 564     senders_[i]->SetRtxSendPayloadType(96);
 565     senders_[i]->SetRtxSsrc(kSenderRtxSsrc + i);
 566     senders_[i]->SetRTXSendStatus(kRtxRetransmitted | kRtxRedundantPayloads);
 567     senders_[i]->SetStorePacketsStatus(true, 100);
 568   }
 569   // First send payloads so that we have something to retransmit.
 570   const size_t kPayloadSize = 500;
 571   const uint8_t payload[kPayloadSize] = {0};
 572   for (int i = 0; i < codec_.numberOfSimulcastStreams; ++i) {
 573     SendFrameOnSender(i + 1, payload, sizeof(payload));
 574   }
 575   transport_.ResetCounters();
 576   senders_[0]->TimeToSendPadding(500);
 577   PaddingMap expected_padding;
 578   expected_padding[kSenderSsrc + 1] = std::make_pair<int, int>(0, 0);
 579   expected_padding[kSenderSsrc + 2] = std::make_pair<int, int>(0, 0);
 580   expected_padding[kSenderSsrc + 3] = std::make_pair<int, int>(0, 0);
 581   expected_padding[kSenderRtxSsrc + 1] = std::make_pair<int, int>(1, 500);
 582   expected_padding[kSenderRtxSsrc + 2] = std::make_pair<int, int>(0, 0);
 583   expected_padding[kSenderRtxSsrc + 3] = std::make_pair<int, int>(0, 0);
 584   ExpectPadding(expected_padding);
 585   senders_[0]->TimeToSendPadding(1000);
 586   expected_padding[kSenderRtxSsrc + 2] = std::make_pair<int, int>(2, 1000);
 587   ExpectPadding(expected_padding);
 588   senders_[0]->TimeToSendPadding(1500);
 589   expected_padding[kSenderRtxSsrc + 3] = std::make_pair<int, int>(3, 1500);
 590   ExpectPadding(expected_padding);
 591 }
 592 }  // namespace webrtc