Merge "Merge upstream-master and enable ARM64" into emu-master-devemu-31-stable-releaseemu-31-release

1 files changed, 47 insertions, 39 deletions

diff --git a/modules/rtp_rtcp/source/rtcp_sender_unittest.cc b/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
index 2c0bb2e2c4..347be79398 100644
--- a/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
+++ b/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
@@ -14,12 +14,12 @@
 #include <utility>
 
 #include "absl/base/macros.h"
+#include "api/units/time_delta.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/bye.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/common_header.h"
 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
 #include "modules/rtp_rtcp/source/rtp_rtcp_impl2.h"
-#include "modules/rtp_rtcp/source/time_util.h"
 #include "rtc_base/rate_limiter.h"
 #include "test/gmock.h"
 #include "test/gtest.h"
@@ -28,7 +28,9 @@
 
 using ::testing::_;
 using ::testing::ElementsAre;
+using ::testing::Eq;
 using ::testing::Invoke;
+using ::testing::Property;
 using ::testing::SizeIs;
 
 namespace webrtc {
@@ -70,43 +72,50 @@ static const uint32_t kStartRtpTimestamp = 0x34567;
 static const uint32_t kRtpTimestamp = 0x45678;
 
 std::unique_ptr<RTCPSender> CreateRtcpSender(
-    const RtpRtcpInterface::Configuration& config,
+    const RTCPSender::Configuration& config,
     bool init_timestamps = true) {
   auto rtcp_sender = std::make_unique<RTCPSender>(config);
   rtcp_sender->SetRemoteSSRC(kRemoteSsrc);
   if (init_timestamps) {
     rtcp_sender->SetTimestampOffset(kStartRtpTimestamp);
-    rtcp_sender->SetLastRtpTime(kRtpTimestamp,
-                                config.clock->TimeInMilliseconds(),
+    rtcp_sender->SetLastRtpTime(kRtpTimestamp, config.clock->CurrentTime(),
                                 /*payload_type=*/0);
   }
   return rtcp_sender;
 }
-
 }  // namespace
 
 class RtcpSenderTest : public ::testing::Test {
  protected:
   RtcpSenderTest()
       : clock_(1335900000),
-        receive_statistics_(ReceiveStatistics::Create(&clock_)),
-        retransmission_rate_limiter_(&clock_, 1000) {
-    RtpRtcpInterface::Configuration configuration = GetDefaultConfig();
-    rtp_rtcp_impl_.reset(new ModuleRtpRtcpImpl2(configuration));
+        receive_statistics_(ReceiveStatistics::Create(&clock_)) {
+    rtp_rtcp_impl_.reset(new ModuleRtpRtcpImpl2(GetDefaultRtpRtcpConfig()));
   }
 
-  RtpRtcpInterface::Configuration GetDefaultConfig() {
-    RtpRtcpInterface::Configuration configuration;
+  RTCPSender::Configuration GetDefaultConfig() {
+    RTCPSender::Configuration configuration;
     configuration.audio = false;
     configuration.clock = &clock_;
     configuration.outgoing_transport = &test_transport_;
-    configuration.retransmission_rate_limiter = &retransmission_rate_limiter_;
-    configuration.rtcp_report_interval_ms = 1000;
+    configuration.rtcp_report_interval = TimeDelta::Millis(1000);
     configuration.receive_statistics = receive_statistics_.get();
     configuration.local_media_ssrc = kSenderSsrc;
     return configuration;
   }
 
+  RtpRtcpInterface::Configuration GetDefaultRtpRtcpConfig() {
+    RTCPSender::Configuration config = GetDefaultConfig();
+    RtpRtcpInterface::Configuration result;
+    result.audio = config.audio;
+    result.clock = config.clock;
+    result.outgoing_transport = config.outgoing_transport;
+    result.rtcp_report_interval_ms = config.rtcp_report_interval->ms();
+    result.receive_statistics = config.receive_statistics;
+    result.local_media_ssrc = config.local_media_ssrc;
+    return result;
+  }
+
   void InsertIncomingPacket(uint32_t remote_ssrc, uint16_t seq_num) {
     RtpPacketReceived packet;
     packet.SetSsrc(remote_ssrc);
@@ -126,7 +135,6 @@ class RtcpSenderTest : public ::testing::Test {
   TestTransport test_transport_;
   std::unique_ptr<ReceiveStatistics> receive_statistics_;
   std::unique_ptr<ModuleRtpRtcpImpl2> rtp_rtcp_impl_;
-  RateLimiter retransmission_rate_limiter_;
 };
 
 TEST_F(RtcpSenderTest, SetRtcpStatus) {
@@ -139,7 +147,7 @@ TEST_F(RtcpSenderTest, SetRtcpStatus) {
 TEST_F(RtcpSenderTest, SetSendingStatus) {
   auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
   EXPECT_FALSE(rtcp_sender->Sending());
-  EXPECT_EQ(0, rtcp_sender->SetSendingStatus(feedback_state(), true));
+  rtcp_sender->SetSendingStatus(feedback_state(), true);
   EXPECT_TRUE(rtcp_sender->Sending());
 }
 
@@ -158,7 +166,7 @@ TEST_F(RtcpSenderTest, SendSr) {
   rtcp_sender->SetSendingStatus(feedback_state, true);
   feedback_state.packets_sent = kPacketCount;
   feedback_state.media_bytes_sent = kOctetCount;
-  NtpTime ntp = TimeMicrosToNtp(clock_.TimeInMicroseconds());
+  NtpTime ntp = clock_.CurrentNtpTime();
   EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state, kRtcpSr));
   EXPECT_EQ(1, parser()->sender_report()->num_packets());
   EXPECT_EQ(kSenderSsrc, parser()->sender_report()->sender_ssrc());
@@ -205,11 +213,11 @@ TEST_F(RtcpSenderTest, SendConsecutiveSrWithExactSlope) {
 }
 
 TEST_F(RtcpSenderTest, DoNotSendSrBeforeRtp) {
-  RtpRtcpInterface::Configuration config;
+  RTCPSender::Configuration config;
   config.clock = &clock_;
   config.receive_statistics = receive_statistics_.get();
   config.outgoing_transport = &test_transport_;
-  config.rtcp_report_interval_ms = 1000;
+  config.rtcp_report_interval = TimeDelta::Millis(1000);
   config.local_media_ssrc = kSenderSsrc;
   auto rtcp_sender = CreateRtcpSender(config, /*init_timestamps=*/false);
   rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
@@ -226,11 +234,11 @@ TEST_F(RtcpSenderTest, DoNotSendSrBeforeRtp) {
 }
 
 TEST_F(RtcpSenderTest, DoNotSendCompundBeforeRtp) {
-  RtpRtcpInterface::Configuration config;
+  RTCPSender::Configuration config;
   config.clock = &clock_;
   config.receive_statistics = receive_statistics_.get();
   config.outgoing_transport = &test_transport_;
-  config.rtcp_report_interval_ms = 1000;
+  config.rtcp_report_interval = TimeDelta::Millis(1000);
   config.local_media_ssrc = kSenderSsrc;
   auto rtcp_sender = CreateRtcpSender(config, /*init_timestamps=*/false);
   rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
@@ -276,11 +284,11 @@ TEST_F(RtcpSenderTest, SendRrWithTwoReportBlocks) {
   EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpRr));
   EXPECT_EQ(1, parser()->receiver_report()->num_packets());
   EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->sender_ssrc());
-  EXPECT_EQ(2U, parser()->receiver_report()->report_blocks().size());
-  EXPECT_EQ(kRemoteSsrc,
-            parser()->receiver_report()->report_blocks()[0].source_ssrc());
-  EXPECT_EQ(kRemoteSsrc + 1,
-            parser()->receiver_report()->report_blocks()[1].source_ssrc());
+  EXPECT_THAT(
+      parser()->receiver_report()->report_blocks(),
+      UnorderedElementsAre(
+          Property(&rtcp::ReportBlock::source_ssrc, Eq(kRemoteSsrc)),
+          Property(&rtcp::ReportBlock::source_ssrc, Eq(kRemoteSsrc + 1))));
 }
 
 TEST_F(RtcpSenderTest, SendSdes) {
@@ -315,8 +323,8 @@ TEST_F(RtcpSenderTest, SendBye) {
 TEST_F(RtcpSenderTest, StopSendingTriggersBye) {
   auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
   rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
-  EXPECT_EQ(0, rtcp_sender->SetSendingStatus(feedback_state(), true));
-  EXPECT_EQ(0, rtcp_sender->SetSendingStatus(feedback_state(), false));
+  rtcp_sender->SetSendingStatus(feedback_state(), true);
+  rtcp_sender->SetSendingStatus(feedback_state(), false);
   EXPECT_EQ(1, parser()->bye()->num_packets());
   EXPECT_EQ(kSenderSsrc, parser()->bye()->sender_ssrc());
 }
@@ -509,12 +517,12 @@ TEST_F(RtcpSenderTest, SendXrWithMultipleDlrrSubBlocks) {
 }
 
 TEST_F(RtcpSenderTest, SendXrWithRrtr) {
-  RtpRtcpInterface::Configuration config = GetDefaultConfig();
+  RTCPSender::Configuration config = GetDefaultConfig();
   config.non_sender_rtt_measurement = true;
   auto rtcp_sender = CreateRtcpSender(config);
   rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
-  EXPECT_EQ(0, rtcp_sender->SetSendingStatus(feedback_state(), false));
-  NtpTime ntp = TimeMicrosToNtp(clock_.TimeInMicroseconds());
+  rtcp_sender->SetSendingStatus(feedback_state(), false);
+  NtpTime ntp = clock_.CurrentNtpTime();
   EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpReport));
   EXPECT_EQ(1, parser()->xr()->num_packets());
   EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc());
@@ -524,33 +532,33 @@ TEST_F(RtcpSenderTest, SendXrWithRrtr) {
 }
 
 TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfSending) {
-  RtpRtcpInterface::Configuration config = GetDefaultConfig();
+  RTCPSender::Configuration config = GetDefaultConfig();
   config.non_sender_rtt_measurement = true;
   auto rtcp_sender = CreateRtcpSender(config);
   rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
-  EXPECT_EQ(0, rtcp_sender->SetSendingStatus(feedback_state(), true));
+  rtcp_sender->SetSendingStatus(feedback_state(), true);
   EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpReport));
   EXPECT_EQ(0, parser()->xr()->num_packets());
 }
 
 TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfNotEnabled) {
-  RtpRtcpInterface::Configuration config = GetDefaultConfig();
+  RTCPSender::Configuration config = GetDefaultConfig();
   config.non_sender_rtt_measurement = false;
   auto rtcp_sender = CreateRtcpSender(config);
   rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
-  EXPECT_EQ(0, rtcp_sender->SetSendingStatus(feedback_state(), false));
+  rtcp_sender->SetSendingStatus(feedback_state(), false);
   EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpReport));
   EXPECT_EQ(0, parser()->xr()->num_packets());
 }
 
 TEST_F(RtcpSenderTest, TestRegisterRtcpPacketTypeObserver) {
   RtcpPacketTypeCounterObserverImpl observer;
-  RtpRtcpInterface::Configuration config;
+  RTCPSender::Configuration config;
   config.clock = &clock_;
   config.receive_statistics = receive_statistics_.get();
   config.outgoing_transport = &test_transport_;
   config.rtcp_packet_type_counter_observer = &observer;
-  config.rtcp_report_interval_ms = 1000;
+  config.rtcp_report_interval = TimeDelta::Millis(1000);
   auto rtcp_sender = CreateRtcpSender(config);
   rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
   EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpPli));
@@ -642,16 +650,16 @@ TEST_F(RtcpSenderTest, ByeMustBeLast) {
       }));
 
   // Re-configure rtcp_sender with mock_transport_
-  RtpRtcpInterface::Configuration config;
+  RTCPSender::Configuration config;
   config.clock = &clock_;
   config.receive_statistics = receive_statistics_.get();
   config.outgoing_transport = &mock_transport;
-  config.rtcp_report_interval_ms = 1000;
+  config.rtcp_report_interval = TimeDelta::Millis(1000);
   config.local_media_ssrc = kSenderSsrc;
   auto rtcp_sender = CreateRtcpSender(config);
 
   rtcp_sender->SetTimestampOffset(kStartRtpTimestamp);
-  rtcp_sender->SetLastRtpTime(kRtpTimestamp, clock_.TimeInMilliseconds(),
+  rtcp_sender->SetLastRtpTime(kRtpTimestamp, clock_.CurrentTime(),
                               /*payload_type=*/0);
 
   // Set up REMB info to be included with BYE.