Unify newapi::RtcpMode and RTCPMethod.

webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 244 matching lines @@
 
   SimulatedClock clock_;
   TestTransport test_transport_;
   rtc::scoped_ptr<ReceiveStatistics> receive_statistics_;
   rtc::scoped_ptr<ModuleRtpRtcpImpl> rtp_rtcp_impl_;
   rtc::scoped_ptr<RTCPSender> rtcp_sender_;
 };
 
 TEST_F(RtcpSenderTest, SetRtcpStatus) {
   EXPECT_EQ(kRtcpOff, rtcp_sender_->Status());
-  rtcp_sender_->SetRTCPStatus(kRtcpNonCompound);
-  EXPECT_EQ(kRtcpNonCompound, rtcp_sender_->Status());
+  rtcp_sender_->SetRTCPStatus(kRtcpReducedSize);
+  EXPECT_EQ(kRtcpReducedSize, rtcp_sender_->Status());
 }
 
 TEST_F(RtcpSenderTest, SetSendingStatus) {
   EXPECT_FALSE(rtcp_sender_->Sending());
   EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true));
   EXPECT_TRUE(rtcp_sender_->Sending());
 }
 
 TEST_F(RtcpSenderTest, NoPacketSentIfOff) {
   rtcp_sender_->SetRTCPStatus(kRtcpOff);
   EXPECT_EQ(-1, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr));
 }
 
 TEST_F(RtcpSenderTest, SendSr) {
   const uint32_t kPacketCount = 0x12345;
   const uint32_t kOctetCount = 0x23456;
-  rtcp_sender_->SetRTCPStatus(kRtcpNonCompound);
+  rtcp_sender_->SetRTCPStatus(kRtcpReducedSize);
   RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
   feedback_state.packets_sent = kPacketCount;
   feedback_state.media_bytes_sent = kOctetCount;
   uint32_t ntp_secs;
   uint32_t ntp_frac;
   clock_.CurrentNtp(ntp_secs, ntp_frac);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr));
   EXPECT_EQ(1, parser()->sender_report()->num_packets());
   EXPECT_EQ(kSenderSsrc, parser()->sender_report()->Ssrc());
   EXPECT_EQ(ntp_secs, parser()->sender_report()->NtpSec());
   EXPECT_EQ(ntp_frac, parser()->sender_report()->NtpFrac());
   EXPECT_EQ(kPacketCount, parser()->sender_report()->PacketCount());
   EXPECT_EQ(kOctetCount, parser()->sender_report()->OctetCount());
   EXPECT_EQ(0, parser()->report_block()->num_packets());
 }
 
 TEST_F(RtcpSenderTest, SendRr) {
-  rtcp_sender_->SetRTCPStatus(kRtcpNonCompound);
+  rtcp_sender_->SetRTCPStatus(kRtcpReducedSize);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr));
   EXPECT_EQ(1, parser()->receiver_report()->num_packets());
   EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->Ssrc());
   EXPECT_EQ(0, parser()->report_block()->num_packets());
 }
 
 TEST_F(RtcpSenderTest, SendRrWithOneReportBlock) {
   const uint16_t kSeqNum = 11111;
   InsertIncomingPacket(kRemoteSsrc, kSeqNum);
   rtcp_sender_->SetRTCPStatus(kRtcpCompound);
@@ skipping 14 matching lines @@
   rtcp_sender_->SetRTCPStatus(kRtcpCompound);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr));
   EXPECT_EQ(1, parser()->receiver_report()->num_packets());
   EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->Ssrc());
   EXPECT_EQ(2, parser()->report_block()->num_packets());
   EXPECT_EQ(1, parser()->report_blocks_per_ssrc(kRemoteSsrc));
   EXPECT_EQ(1, parser()->report_blocks_per_ssrc(kRemoteSsrc + 1));
 }
 
 TEST_F(RtcpSenderTest, SendSdes) {
-  rtcp_sender_->SetRTCPStatus(kRtcpNonCompound);
+  rtcp_sender_->SetRTCPStatus(kRtcpReducedSize);
   EXPECT_EQ(0, rtcp_sender_->SetCNAME("alice@host"));
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSdes));
   EXPECT_EQ(1, parser()->sdes()->num_packets());
   EXPECT_EQ(1, parser()->sdes_chunk()->num_packets());
   EXPECT_EQ(kSenderSsrc, parser()->sdes_chunk()->Ssrc());
   EXPECT_EQ("alice@host", parser()->sdes_chunk()->Cname());
 }
 
 TEST_F(RtcpSenderTest, SdesIncludedInCompoundPacket) {
   rtcp_sender_->SetRTCPStatus(kRtcpCompound);
   EXPECT_EQ(0, rtcp_sender_->SetCNAME("alice@host"));
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
   EXPECT_EQ(1, parser()->receiver_report()->num_packets());
   EXPECT_EQ(1, parser()->sdes()->num_packets());
   EXPECT_EQ(1, parser()->sdes_chunk()->num_packets());
 }
 
 TEST_F(RtcpSenderTest, SendBye) {
-  rtcp_sender_->SetRTCPStatus(kRtcpNonCompound);
+  rtcp_sender_->SetRTCPStatus(kRtcpReducedSize);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpBye));
   EXPECT_EQ(1, parser()->bye()->num_packets());
   EXPECT_EQ(kSenderSsrc, parser()->bye()->Ssrc());
 }
 
 TEST_F(RtcpSenderTest, StopSendingTriggersBye) {
-  rtcp_sender_->SetRTCPStatus(kRtcpNonCompound);
+  rtcp_sender_->SetRTCPStatus(kRtcpReducedSize);
   EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true));
   EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false));
   EXPECT_EQ(1, parser()->bye()->num_packets());
   EXPECT_EQ(kSenderSsrc, parser()->bye()->Ssrc());
 }
 
 TEST_F(RtcpSenderTest, SendApp) {
   const uint8_t kSubType = 30;
   uint32_t name = 'n' << 24;
   name += 'a' << 16;
   name += 'm' << 8;
   name += 'e';
   const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'};
   const uint16_t kDataLength = sizeof(kData) / sizeof(kData[0]);
   EXPECT_EQ(0, rtcp_sender_->SetApplicationSpecificData(kSubType, name, kData,
                                                         kDataLength));
-  rtcp_sender_->SetRTCPStatus(kRtcpNonCompound);
+  rtcp_sender_->SetRTCPStatus(kRtcpReducedSize);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpApp));
   EXPECT_EQ(1, parser()->app()->num_packets());
   EXPECT_EQ(kSubType, parser()->app()->SubType());
   EXPECT_EQ(name, parser()->app()->Name());
   EXPECT_EQ(1, parser()->app_item()->num_packets());
   EXPECT_EQ(kDataLength, parser()->app_item()->DataLength());
   EXPECT_EQ(0, strncmp(reinterpret_cast<const char*>(kData),
       reinterpret_cast<const char*>(parser()->app_item()->Data()),
       parser()->app_item()->DataLength()));
 }
 
 TEST_F(RtcpSenderTest, SendEmptyApp) {
   const uint8_t kSubType = 30;
   const uint32_t kName = 0x6E616D65;
 
   EXPECT_EQ(
       0, rtcp_sender_->SetApplicationSpecificData(kSubType, kName, nullptr, 0));
 
-  rtcp_sender_->SetRTCPStatus(kRtcpNonCompound);
+  rtcp_sender_->SetRTCPStatus(kRtcpReducedSize);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpApp));
   EXPECT_EQ(1, parser()->app()->num_packets());
   EXPECT_EQ(kSubType, parser()->app()->SubType());
   EXPECT_EQ(kName, parser()->app()->Name());
   EXPECT_EQ(0, parser()->app_item()->num_packets());
 }
 
 TEST_F(RtcpSenderTest, SetInvalidApplicationSpecificData) {
   const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't'};
   const uint16_t kInvalidDataLength = sizeof(kData) / sizeof(kData[0]);
   EXPECT_EQ(-1, rtcp_sender_->SetApplicationSpecificData(
       0, 0, kData, kInvalidDataLength));  // Should by multiple of 4.
 }
 
 TEST_F(RtcpSenderTest, SendFirNonRepeat) {
-  rtcp_sender_->SetRTCPStatus(kRtcpNonCompound);
+  rtcp_sender_->SetRTCPStatus(kRtcpReducedSize);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpFir));
   EXPECT_EQ(1, parser()->fir()->num_packets());
   EXPECT_EQ(kSenderSsrc, parser()->fir()->Ssrc());
   EXPECT_EQ(1, parser()->fir_item()->num_packets());
   EXPECT_EQ(kRemoteSsrc, parser()->fir_item()->Ssrc());
   uint8_t seq = parser()->fir_item()->SeqNum();
   // Sends non-repeat FIR as default.
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpFir));
   EXPECT_EQ(2, parser()->fir()->num_packets());
   EXPECT_EQ(2, parser()->fir_item()->num_packets());
   EXPECT_EQ(seq + 1, parser()->fir_item()->SeqNum());
 }
 
 TEST_F(RtcpSenderTest, SendFirRepeat) {
-  rtcp_sender_->SetRTCPStatus(kRtcpNonCompound);
+  rtcp_sender_->SetRTCPStatus(kRtcpReducedSize);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpFir));
   EXPECT_EQ(1, parser()->fir()->num_packets());
   EXPECT_EQ(1, parser()->fir_item()->num_packets());
   uint8_t seq = parser()->fir_item()->SeqNum();
   const bool kRepeat = true;
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpFir, 0, nullptr,
                                       kRepeat));
   EXPECT_EQ(2, parser()->fir()->num_packets());
   EXPECT_EQ(2, parser()->fir_item()->num_packets());
   EXPECT_EQ(seq, parser()->fir_item()->SeqNum());
 }
 
 TEST_F(RtcpSenderTest, SendPli) {
-  rtcp_sender_->SetRTCPStatus(kRtcpNonCompound);
+  rtcp_sender_->SetRTCPStatus(kRtcpReducedSize);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli));
   EXPECT_EQ(1, parser()->pli()->num_packets());
   EXPECT_EQ(kSenderSsrc, parser()->pli()->Ssrc());
   EXPECT_EQ(kRemoteSsrc, parser()->pli()->MediaSsrc());
 }
 
 TEST_F(RtcpSenderTest, SendRpsi) {
   const uint64_t kPictureId = 0x41;
   const int8_t kPayloadType = 100;
-  rtcp_sender_->SetRTCPStatus(kRtcpNonCompound);
+  rtcp_sender_->SetRTCPStatus(kRtcpReducedSize);
   RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
   feedback_state.send_payload_type = kPayloadType;
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpRpsi, 0, nullptr,
                                       false, kPictureId));
   EXPECT_EQ(kPayloadType, parser()->rpsi()->PayloadType());
   EXPECT_EQ(kPictureId, parser()->rpsi()->PictureId());
 }
 
 TEST_F(RtcpSenderTest, SendSli) {
   const uint16_t kFirstMb = 0;
   const uint16_t kNumberOfMb = 0x1FFF;
   const uint8_t kPictureId = 60;
-  rtcp_sender_->SetRTCPStatus(kRtcpNonCompound);
+  rtcp_sender_->SetRTCPStatus(kRtcpReducedSize);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSli, 0, nullptr,
                                       false, kPictureId));
   EXPECT_EQ(1, parser()->sli()->num_packets());
   EXPECT_EQ(kSenderSsrc, parser()->sli()->Ssrc());
   EXPECT_EQ(kRemoteSsrc, parser()->sli()->MediaSsrc());
   EXPECT_EQ(1, parser()->sli_item()->num_packets());
   EXPECT_EQ(kFirstMb, parser()->sli_item()->FirstMb());
   EXPECT_EQ(kNumberOfMb, parser()->sli_item()->NumberOfMb());
   EXPECT_EQ(kPictureId, parser()->sli_item()->PictureId());
 }
 
 TEST_F(RtcpSenderTest, SendNack) {
-  rtcp_sender_->SetRTCPStatus(kRtcpNonCompound);
+  rtcp_sender_->SetRTCPStatus(kRtcpReducedSize);
   const uint16_t kList[] = {0, 1, 16};
   const int32_t kListLength = sizeof(kList) / sizeof(kList[0]);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpNack, kListLength,
                                       kList));
   EXPECT_EQ(1, parser()->nack()->num_packets());
   EXPECT_EQ(kSenderSsrc, parser()->nack()->Ssrc());
   EXPECT_EQ(kRemoteSsrc, parser()->nack()->MediaSsrc());
   EXPECT_EQ(1, parser()->nack_item()->num_packets());
   EXPECT_THAT(parser()->nack_item()->last_nack_list(), ElementsAre(0, 1, 16));
 }
 
 TEST_F(RtcpSenderTest, SendRemb) {
   const int kBitrate = 261011;
   std::vector<uint32_t> ssrcs;
   ssrcs.push_back(kRemoteSsrc);
   ssrcs.push_back(kRemoteSsrc + 1);
-  rtcp_sender_->SetRTCPStatus(kRtcpNonCompound);
+  rtcp_sender_->SetRTCPStatus(kRtcpReducedSize);
   rtcp_sender_->SetREMBData(kBitrate, ssrcs);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRemb));
   EXPECT_EQ(1, parser()->psfb_app()->num_packets());
   EXPECT_EQ(kSenderSsrc, parser()->psfb_app()->Ssrc());
   EXPECT_EQ(1, parser()->remb_item()->num_packets());
   EXPECT_EQ(kBitrate, parser()->remb_item()->last_bitrate_bps());
   EXPECT_THAT(parser()->remb_item()->last_ssrc_list(),
               ElementsAre(kRemoteSsrc, kRemoteSsrc + 1));
 }
 
@@ skipping 19 matching lines @@
   std::vector<uint32_t> ssrcs;
   ssrcs.push_back(kRemoteSsrc);
   rtcp_sender_->SetRTCPStatus(kRtcpCompound);
   rtcp_sender_->SetREMBData(kBitrate, ssrcs);
   EXPECT_FALSE(rtcp_sender_->REMB());
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
   EXPECT_EQ(0, parser()->psfb_app()->num_packets());
 }
 
 TEST_F(RtcpSenderTest, SendXrWithVoipMetric) {
-  rtcp_sender_->SetRTCPStatus(kRtcpNonCompound);
+  rtcp_sender_->SetRTCPStatus(kRtcpReducedSize);
   RTCPVoIPMetric metric;
   metric.lossRate = 1;
   metric.discardRate = 2;
   metric.burstDensity = 3;
   metric.gapDensity = 4;
   metric.burstDuration = 0x1111;
   metric.gapDuration = 0x2222;
   metric.roundTripDelay = 0x3333;
   metric.endSystemDelay = 0x4444;
   metric.signalLevel = 5;
@@ skipping 117 matching lines @@
   // The first report should no longer be stored.
   EXPECT_FALSE(rtcp_sender_->SendTimeOfXrRrReport(initial_mid_ntp, &time_ms));
 }
 
 TEST_F(RtcpSenderTest, TestRegisterRtcpPacketTypeObserver) {
   RtcpPacketTypeCounterObserverImpl observer;
   rtcp_sender_.reset(
       new RTCPSender(false, &clock_, receive_statistics_.get(), &observer));
   rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
   EXPECT_EQ(0, rtcp_sender_->RegisterSendTransport(&test_transport_));
-  rtcp_sender_->SetRTCPStatus(kRtcpNonCompound);
+  rtcp_sender_->SetRTCPStatus(kRtcpReducedSize);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli));
   EXPECT_EQ(1, parser()->pli()->num_packets());
   EXPECT_EQ(kRemoteSsrc, observer.ssrc_);
   EXPECT_EQ(1U, observer.counter_.pli_packets);
   EXPECT_EQ(clock_.TimeInMilliseconds(),
             observer.counter_.first_packet_time_ms);
 }
 
 TEST_F(RtcpSenderTest, SendTmmbr) {
   const unsigned int kBitrateBps = 312000;
-  rtcp_sender_->SetRTCPStatus(kRtcpNonCompound);
+  rtcp_sender_->SetRTCPStatus(kRtcpReducedSize);
   rtcp_sender_->SetTargetBitrate(kBitrateBps);
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpTmmbr));
   EXPECT_EQ(1, parser()->tmmbr()->num_packets());
   EXPECT_EQ(kSenderSsrc, parser()->tmmbr()->Ssrc());
   EXPECT_EQ(1, parser()->tmmbr_item()->num_packets());
   EXPECT_EQ(kBitrateBps / 1000, parser()->tmmbr_item()->BitrateKbps());
   // TODO(asapersson): tmmbr_item()->Overhead() looks broken, always zero.
 }
 
 TEST_F(RtcpSenderTest, TmmbrIncludedInCompoundPacketIfEnabled) {
@@ skipping 59 matching lines @@
   rtcp_sender_->SetREMBData(kBitrate, ssrcs);
   std::set<RTCPPacketType> packet_types;
   packet_types.insert(kRtcpRemb);
   packet_types.insert(kRtcpPli);
   EXPECT_EQ(0, rtcp_sender_->SendCompoundRTCP(feedback_state(), packet_types));
   EXPECT_EQ(1, parser()->remb_item()->num_packets());
   EXPECT_EQ(1, parser()->pli()->num_packets());
 }
 
 }  // namespace webrtc