OnReceivedUplinkPacketLossFraction() receives [const rtc::Optional<float>&]

webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc

 /*
  *  Copyright (c) 2015 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 219 matching lines @@
 // that the loss rate as reported by the encoder is |expected_return| for all
 // of them.
 void TestSetPacketLossRate(AudioEncoderOpusStates* states,
                            const std::vector<float>& losses,
                            float expected_return) {
   // |kSampleIntervalMs| is chosen to ease the calculation since
   // 0.9999 ^ 184198 = 1e-8. Which minimizes the effect of
   // PacketLossFractionSmoother used in AudioEncoderOpus.
   constexpr int64_t kSampleIntervalMs = 184198;
   for (float loss : losses) {
-    states->encoder->OnReceivedUplinkPacketLossFraction(loss);
+    states->encoder->OnReceivedUplinkPacketLossFraction(
+        rtc::Optional<float>(loss));
     states->simulated_clock->AdvanceTimeMilliseconds(kSampleIntervalMs);
     EXPECT_FLOAT_EQ(expected_return, states->encoder->packet_loss_rate());
   }
 }
 
 }  // namespace
 
 TEST(AudioEncoderOpusTest, PacketLossRateOptimized) {
   auto states = CreateCodec(1);
   auto I = [](float a, float b) { return IntervalSteps(a, b, 10); };
@@ skipping 34 matching lines @@
 TEST(AudioEncoderOpusTest,
      InvokeAudioNetworkAdaptorOnReceivedUplinkPacketLossFraction) {
   auto states = CreateCodec(2);
   states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr);
 
   auto config = CreateEncoderRuntimeConfig();
   EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig())
       .WillOnce(Return(config));
 
   // Since using mock audio network adaptor, any packet loss fraction is fine.
-  constexpr float kUplinkPacketLoss = 0.1f;
+  const auto kUplinkPacketLoss = rtc::Optional<float>(0.1f);
   EXPECT_CALL(**states.mock_audio_network_adaptor,
               SetUplinkPacketLossFraction(kUplinkPacketLoss));
-  states.encoder->OnReceivedUplinkPacketLossFraction(kUplinkPacketLoss);
+  states.encoder->OnReceivedUplinkPacketLossFraction(
+      rtc::Optional<float>(kUplinkPacketLoss));
 
   CheckEncoderRuntimeConfig(states.encoder.get(), config);
 }
 
 TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedUplinkBandwidth) {
   auto states = CreateCodec(2);
   states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr);
 
   auto config = CreateEncoderRuntimeConfig();
   EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig())
@@ skipping 44 matching lines @@
 
   CheckEncoderRuntimeConfig(states.encoder.get(), config);
 }
 
 TEST(AudioEncoderOpusTest,
      PacketLossFractionSmoothedOnSetUplinkPacketLossFraction) {
   auto states = CreateCodec(2);
 
   // The values are carefully chosen so that if no smoothing is made, the test
   // will fail.
-  constexpr float kPacketLossFraction_1 = 0.02f;
-  constexpr float kPacketLossFraction_2 = 0.198f;
+  const auto kPacketLossFraction_1 = rtc::Optional<float>(0.02f);
+  const auto kPacketLossFraction_2 = rtc::Optional<float>(0.198f);
   // |kSecondSampleTimeMs| is chosen to ease the calculation since
   // 0.9999 ^ 6931 = 0.5.
   constexpr int64_t kSecondSampleTimeMs = 6931;
 
   // First time, no filtering.
   states.encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_1);
   EXPECT_FLOAT_EQ(0.01f, states.encoder->packet_loss_rate());
 
   states.simulated_clock->AdvanceTimeMilliseconds(kSecondSampleTimeMs);
   states.encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_2);
@@ skipping 165 matching lines @@
 
     // Should encode now.
     states.encoder->Encode(rtp_timestamp, audio_frames->GetNextBlock(),
                            &encoded);
     EXPECT_GT(encoded.size(), 0u);
     encoded.Clear();
   }
 }
 
 }  // namespace webrtc