Allow ANA to receive RPLR (recoverable packet loss rate) indications

webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc

 /*
  *  Copyright (c) 2016 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 18 matching lines @@
 
 constexpr size_t kNumControllers = 2;
 
 constexpr int64_t kClockInitialTimeMs = 12345678;
 
 MATCHER_P(NetworkMetricsIs, metric, "") {
   return arg.uplink_bandwidth_bps == metric.uplink_bandwidth_bps &&
          arg.target_audio_bitrate_bps == metric.target_audio_bitrate_bps &&
          arg.rtt_ms == metric.rtt_ms &&
          arg.overhead_bytes_per_packet == metric.overhead_bytes_per_packet &&
-         arg.uplink_packet_loss_fraction == metric.uplink_packet_loss_fraction;
+         arg.uplink_packet_loss_fraction ==
+             metric.uplink_packet_loss_fraction &&
+         arg.uplink_recoverable_packet_loss_fraction ==
+             metric.uplink_recoverable_packet_loss_fraction;
 }
 
 MATCHER_P(EncoderRuntimeConfigIs, config, "") {
   return arg.bitrate_bps == config.bitrate_bps &&
          arg.frame_length_ms == config.frame_length_ms &&
          arg.uplink_packet_loss_fraction ==
              config.uplink_packet_loss_fraction &&
          arg.enable_fec == config.enable_fec &&
          arg.enable_dtx == config.enable_dtx &&
          arg.num_channels == config.num_channels;
@@ skipping 70 matching lines @@
 TEST(AudioNetworkAdaptorImplTest,
      UpdateNetworkMetricsIsCalledOnSetUplinkPacketLossFraction) {
   auto states = CreateAudioNetworkAdaptor();
   constexpr float kPacketLoss = 0.7f;
   Controller::NetworkMetrics check;
   check.uplink_packet_loss_fraction = rtc::Optional<float>(kPacketLoss);
   SetExpectCallToUpdateNetworkMetrics(states.mock_controllers, check);
   states.audio_network_adaptor->SetUplinkPacketLossFraction(kPacketLoss);
 }
 
+TEST(AudioNetworkAdaptorImplTest,
+     UpdateNetworkMetricsIsCalledOnSetUplinkRecoverablePacketLossFraction) {
+  auto states = CreateAudioNetworkAdaptor();
+  constexpr float kRecoverablePacketLoss = 0.1f;
+  Controller::NetworkMetrics check;
+  check.uplink_recoverable_packet_loss_fraction =
+      rtc::Optional<float>(kRecoverablePacketLoss);
+  SetExpectCallToUpdateNetworkMetrics(states.mock_controllers, check);
+  states.audio_network_adaptor->SetUplinkRecoverablePacketLossFraction(
+      kRecoverablePacketLoss);
+}
+
 TEST(AudioNetworkAdaptorImplTest, UpdateNetworkMetricsIsCalledOnSetRtt) {
   auto states = CreateAudioNetworkAdaptor();
   constexpr int kRtt = 100;
   Controller::NetworkMetrics check;
   check.rtt_ms = rtc::Optional<int>(kRtt);
   SetExpectCallToUpdateNetworkMetrics(states.mock_controllers, check);
   states.audio_network_adaptor->SetRtt(kRtt);
 }
 
 TEST(AudioNetworkAdaptorImplTest,
@@ skipping 39 matching lines @@
                                        kClockInitialTimeMs));
   states.audio_network_adaptor->GetEncoderRuntimeConfig();
 }
 
 TEST(AudioNetworkAdaptorImplTest,
      DumpNetworkMetricsIsCalledOnSetNetworkMetrics) {
   auto states = CreateAudioNetworkAdaptor();
 
   constexpr int kBandwidth = 16000;
   constexpr float kPacketLoss = 0.7f;
+  const auto kRecoverablePacketLoss = 0.2f;
   constexpr int kRtt = 100;
   constexpr int kTargetAudioBitrate = 15000;
   constexpr size_t kOverhead = 64;
 
   Controller::NetworkMetrics check;
   check.uplink_bandwidth_bps = rtc::Optional<int>(kBandwidth);
   int64_t timestamp_check = kClockInitialTimeMs;
 
   EXPECT_CALL(*states.mock_debug_dump_writer,
               DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
   states.audio_network_adaptor->SetUplinkBandwidth(kBandwidth);
 
   states.simulated_clock->AdvanceTimeMilliseconds(100);
   timestamp_check += 100;
   check.uplink_packet_loss_fraction = rtc::Optional<float>(kPacketLoss);
   EXPECT_CALL(*states.mock_debug_dump_writer,
               DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
   states.audio_network_adaptor->SetUplinkPacketLossFraction(kPacketLoss);
 
+  states.simulated_clock->AdvanceTimeMilliseconds(50);
+  timestamp_check += 50;
+  check.uplink_recoverable_packet_loss_fraction =
+      rtc::Optional<float>(kRecoverablePacketLoss);
+  EXPECT_CALL(*states.mock_debug_dump_writer,
+              DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
+  states.audio_network_adaptor->SetUplinkRecoverablePacketLossFraction(
+      kRecoverablePacketLoss);
+
   states.simulated_clock->AdvanceTimeMilliseconds(200);
   timestamp_check += 200;
   check.rtt_ms = rtc::Optional<int>(kRtt);
   EXPECT_CALL(*states.mock_debug_dump_writer,
               DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
   states.audio_network_adaptor->SetRtt(kRtt);
 
   states.simulated_clock->AdvanceTimeMilliseconds(150);
   timestamp_check += 150;
   check.target_audio_bitrate_bps = rtc::Optional<int>(kTargetAudioBitrate);
@@ skipping 19 matching lines @@
   EXPECT_CALL(*states.mock_controllers[0], MakeDecision(_))
       .WillOnce(SetArgPointee<0>(config));
 
   EXPECT_CALL(*states.event_log,
               LogAudioNetworkAdaptation(EncoderRuntimeConfigIs(config)))
       .Times(1);
   states.audio_network_adaptor->GetEncoderRuntimeConfig();
 }
 
 }  // namespace webrtc