Use overloaded UpdateNetworkMetrics()

Use an overloaded version of UpdateNetworkMetrics() which does not require us to explicitly pass in an rtc::Optional.

BUG=None

Review-Url: https://codereview.webrtc.org/2899313004
Cr-Commit-Position: refs/heads/master@{#18347}

webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based_unittest.cc

@@ -99,8 +99,6 @@ void UpdateNetworkMetrics(FecControllerPlrBasedTestStates* states,
   }
 }
 
-// TODO(eladalon): In a separate CL (to make reviewers' lives easier), use
-// this where applicable.
 void UpdateNetworkMetrics(FecControllerPlrBasedTestStates* states,
                           int uplink_bandwidth_bps,
                           float uplink_packet_loss) {
@@ -165,8 +163,8 @@ TEST(FecControllerPlrBasedTest,
 
 TEST(FecControllerPlrBasedTest, EnableFecForHighBandwidth) {
   auto states = CreateFecControllerPlrBased(false);
-  UpdateNetworkMetrics(&states, rtc::Optional<int>(kEnablingBandwidthHigh),
-                       rtc::Optional<float>(kEnablingPacketLossAtHighBw));
+  UpdateNetworkMetrics(&states, kEnablingBandwidthHigh,
+                       kEnablingPacketLossAtHighBw);
   CheckDecision(&states, true, kEnablingPacketLossAtHighBw);
 }
 
@@ -193,8 +191,7 @@ TEST(FecControllerPlrBasedTest, UpdateMultipleNetworkMetricsAtOnce) {
 TEST(FecControllerPlrBasedTest, MaintainFecOffForHighBandwidth) {
   auto states = CreateFecControllerPlrBased(false);
   constexpr float kPacketLoss = kEnablingPacketLossAtHighBw * 0.99f;
-  UpdateNetworkMetrics(&states, rtc::Optional<int>(kEnablingBandwidthHigh),
-                       rtc::Optional<float>(kPacketLoss));
+  UpdateNetworkMetrics(&states, kEnablingBandwidthHigh, kPacketLoss);
   CheckDecision(&states, false, kPacketLoss);
 }
 
@@ -202,10 +199,9 @@ TEST(FecControllerPlrBasedTest, EnableFecForMediumBandwidth) {
   auto states = CreateFecControllerPlrBased(false);
   constexpr float kPacketLoss =
       (kEnablingPacketLossAtLowBw + kEnablingPacketLossAtHighBw) / 2.0;
-  UpdateNetworkMetrics(
-      &states,
-      rtc::Optional<int>((kEnablingBandwidthHigh + kEnablingBandwidthLow) / 2),
-      rtc::Optional<float>(kPacketLoss));
+  UpdateNetworkMetrics(&states,
+                       (kEnablingBandwidthHigh + kEnablingBandwidthLow) / 2,
+                       kPacketLoss);
   CheckDecision(&states, true, kPacketLoss);
 }
 
@@ -213,25 +209,23 @@ TEST(FecControllerPlrBasedTest, MaintainFecOffForMediumBandwidth) {
   auto states = CreateFecControllerPlrBased(false);
   constexpr float kPacketLoss =
       kEnablingPacketLossAtLowBw * 0.49f + kEnablingPacketLossAtHighBw * 0.51f;
-  UpdateNetworkMetrics(
-      &states,
-      rtc::Optional<int>((kEnablingBandwidthHigh + kEnablingBandwidthLow) / 2),
-      rtc::Optional<float>(kPacketLoss));
+  UpdateNetworkMetrics(&states,
+                       (kEnablingBandwidthHigh + kEnablingBandwidthLow) / 2,
+                       kPacketLoss);
   CheckDecision(&states, false, kPacketLoss);
 }
 
 TEST(FecControllerPlrBasedTest, EnableFecForLowBandwidth) {
   auto states = CreateFecControllerPlrBased(false);
-  UpdateNetworkMetrics(&states, rtc::Optional<int>(kEnablingBandwidthLow),
-                       rtc::Optional<float>(kEnablingPacketLossAtLowBw));
+  UpdateNetworkMetrics(&states, kEnablingBandwidthLow,
+                       kEnablingPacketLossAtLowBw);
   CheckDecision(&states, true, kEnablingPacketLossAtLowBw);
 }
 
 TEST(FecControllerPlrBasedTest, MaintainFecOffForLowBandwidth) {
   auto states = CreateFecControllerPlrBased(false);
   constexpr float kPacketLoss = kEnablingPacketLossAtLowBw * 0.99f;
-  UpdateNetworkMetrics(&states, rtc::Optional<int>(kEnablingBandwidthLow),
-                       rtc::Optional<float>(kPacketLoss));
+  UpdateNetworkMetrics(&states, kEnablingBandwidthLow, kPacketLoss);
   CheckDecision(&states, false, kPacketLoss);
 }
 
@@ -239,24 +233,22 @@ TEST(FecControllerPlrBasedTest, MaintainFecOffForVeryLowBandwidth) {
   auto states = CreateFecControllerPlrBased(false);
   // Below |kEnablingBandwidthLow|, no packet loss fraction can cause FEC to
   // turn on.
-  UpdateNetworkMetrics(&states, rtc::Optional<int>(kEnablingBandwidthLow - 1),
-                       rtc::Optional<float>(1.0));
+  UpdateNetworkMetrics(&states, kEnablingBandwidthLow - 1, 1.0);
   CheckDecision(&states, false, 1.0);
 }
 
 TEST(FecControllerPlrBasedTest, DisableFecForHighBandwidth) {
   auto states = CreateFecControllerPlrBased(true);
   constexpr float kPacketLoss = kDisablingPacketLossAtHighBw - kEpsilon;
-  UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthHigh),
-                       rtc::Optional<float>(kPacketLoss));
+  UpdateNetworkMetrics(&states, kDisablingBandwidthHigh, kPacketLoss);
   CheckDecision(&states, false, kPacketLoss);
 }
 
 TEST(FecControllerPlrBasedTest, MaintainFecOnForHighBandwidth) {
   // Note: Disabling happens when the value is strictly below the threshold.
   auto states = CreateFecControllerPlrBased(true);
-  UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthHigh),
-                       rtc::Optional<float>(kDisablingPacketLossAtHighBw));
+  UpdateNetworkMetrics(&states, kDisablingBandwidthHigh,
+                       kDisablingPacketLossAtHighBw);
   CheckDecision(&states, true, kDisablingPacketLossAtHighBw);
 }
 
@@ -265,11 +257,9 @@ TEST(FecControllerPlrBasedTest, DisableFecOnMediumBandwidth) {
   constexpr float kPacketLoss =
       (kDisablingPacketLossAtLowBw + kDisablingPacketLossAtHighBw) / 2.0f -
       kEpsilon;
-  UpdateNetworkMetrics(
-      &states,
-      rtc::Optional<int>((kDisablingBandwidthHigh + kDisablingBandwidthLow) /
-                         2),
-      rtc::Optional<float>(kPacketLoss));
+  UpdateNetworkMetrics(&states,
+                       (kDisablingBandwidthHigh + kDisablingBandwidthLow) / 2,
+                       kPacketLoss);
   CheckDecision(&states, false, kPacketLoss);
 }
 
@@ -277,18 +267,16 @@ TEST(FecControllerPlrBasedTest, MaintainFecOnForMediumBandwidth) {
   auto states = CreateFecControllerPlrBased(true);
   constexpr float kPacketLoss = kDisablingPacketLossAtLowBw * 0.51f +
                                 kDisablingPacketLossAtHighBw * 0.49f - kEpsilon;
-  UpdateNetworkMetrics(
-      &states,
-      rtc::Optional<int>((kEnablingBandwidthHigh + kDisablingBandwidthLow) / 2),
-      rtc::Optional<float>(kPacketLoss));
+  UpdateNetworkMetrics(&states,
+                       (kEnablingBandwidthHigh + kDisablingBandwidthLow) / 2,
+                       kPacketLoss);
   CheckDecision(&states, true, kPacketLoss);
 }
 
 TEST(FecControllerPlrBasedTest, DisableFecForLowBandwidth) {
   auto states = CreateFecControllerPlrBased(true);
   constexpr float kPacketLoss = kDisablingPacketLossAtLowBw - kEpsilon;
-  UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthLow),
-                       rtc::Optional<float>(kPacketLoss));
+  UpdateNetworkMetrics(&states, kDisablingBandwidthLow, kPacketLoss);
   CheckDecision(&states, false, kPacketLoss);
 }
 
@@ -296,8 +284,7 @@ TEST(FecControllerPlrBasedTest, DisableFecForVeryLowBandwidth) {
   auto states = CreateFecControllerPlrBased(true);
   // Below |kEnablingBandwidthLow|, any packet loss fraction can cause FEC to
   // turn off.
-  UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthLow - 1),
-                       rtc::Optional<float>(1.0));
+  UpdateNetworkMetrics(&states, kDisablingBandwidthLow - 1, 1.0);
   CheckDecision(&states, false, 1.0);
 }
 
@@ -311,25 +298,22 @@ TEST(FecControllerPlrBasedTest, CheckBehaviorOnChangingNetworkMetrics) {
   //             |---------5-------> bandwidth
 
   auto states = CreateFecControllerPlrBased(true);
-  UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthLow - 1),
-                       rtc::Optional<float>(1.0));
+  UpdateNetworkMetrics(&states, kDisablingBandwidthLow - 1, 1.0);
   CheckDecision(&states, false, 1.0);
 
-  UpdateNetworkMetrics(
-      &states, rtc::Optional<int>(kEnablingBandwidthLow),
-      rtc::Optional<float>(kEnablingPacketLossAtLowBw * 0.99f));
+  UpdateNetworkMetrics(&states, kEnablingBandwidthLow,
+                       kEnablingPacketLossAtLowBw * 0.99f);
   CheckDecision(&states, false, kEnablingPacketLossAtLowBw * 0.99f);
 
-  UpdateNetworkMetrics(&states, rtc::Optional<int>(kEnablingBandwidthHigh),
-                       rtc::Optional<float>(kEnablingPacketLossAtHighBw));
+  UpdateNetworkMetrics(&states, kEnablingBandwidthHigh,
+                       kEnablingPacketLossAtHighBw);
   CheckDecision(&states, true, kEnablingPacketLossAtHighBw);
 
-  UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthHigh),
-                       rtc::Optional<float>(kDisablingPacketLossAtHighBw));
+  UpdateNetworkMetrics(&states, kDisablingBandwidthHigh,
+                       kDisablingPacketLossAtHighBw);
   CheckDecision(&states, true, kDisablingPacketLossAtHighBw);
 
-  UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthHigh + 1),
-                       rtc::Optional<float>(0.0));
+  UpdateNetworkMetrics(&states, kDisablingBandwidthHigh + 1, 0.0);
   CheckDecision(&states, false, 0.0);
 }
 
@@ -361,25 +345,22 @@ TEST(FecControllerPlrBasedTest, CheckBehaviorOnSpecialCurves) {
           0),
       std::move(mock_smoothing_filter)));
 
-  UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthLow - 1),
-                       rtc::Optional<float>(1.0));
+  UpdateNetworkMetrics(&states, kDisablingBandwidthLow - 1, 1.0);
   CheckDecision(&states, false, 1.0);
 
-  UpdateNetworkMetrics(
-      &states, rtc::Optional<int>(kEnablingBandwidthLow),
-      rtc::Optional<float>(kEnablingPacketLossAtHighBw * 0.99f));
+  UpdateNetworkMetrics(&states, kEnablingBandwidthLow,
+                       kEnablingPacketLossAtHighBw * 0.99f);
   CheckDecision(&states, false, kEnablingPacketLossAtHighBw * 0.99f);
 
-  UpdateNetworkMetrics(&states, rtc::Optional<int>(kEnablingBandwidthHigh),
-                       rtc::Optional<float>(kEnablingPacketLossAtHighBw));
+  UpdateNetworkMetrics(&states, kEnablingBandwidthHigh,
+                       kEnablingPacketLossAtHighBw);
   CheckDecision(&states, true, kEnablingPacketLossAtHighBw);
 
-  UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthHigh),
-                       rtc::Optional<float>(kDisablingPacketLossAtHighBw));
+  UpdateNetworkMetrics(&states, kDisablingBandwidthHigh,
+                       kDisablingPacketLossAtHighBw);
   CheckDecision(&states, true, kDisablingPacketLossAtHighBw);
 
-  UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthHigh + 1),
-                       rtc::Optional<float>(0.0));
+  UpdateNetworkMetrics(&states, kDisablingBandwidthHigh + 1, 0.0);
   CheckDecision(&states, false, 0.0);
 }
 

webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based_unittest.cc

@@ -108,8 +108,6 @@ void UpdateNetworkMetrics(
                        uplink_recoveralbe_packet_loss);
 }
 
-// TODO(eladalon): In a separate CL (to make reviewers' lives easier), use
-// this where applicable.
 void UpdateNetworkMetrics(FecControllerRplrBased* controller,
                           int uplink_bandwidth_bps,
                           float uplink_recoveralbe_packet_loss) {
@@ -185,9 +183,8 @@ TEST(FecControllerRplrBasedTest,
 
 TEST(FecControllerRplrBasedTest, EnableFecForHighBandwidth) {
   auto controller = CreateFecControllerRplrBased(false);
-  UpdateNetworkMetrics(
-      controller.get(), rtc::Optional<int>(kEnablingBandwidthHigh),
-      rtc::Optional<float>(kEnablingRecoverablePacketLossAtHighBw));
+  UpdateNetworkMetrics(controller.get(), kEnablingBandwidthHigh,
+                       kEnablingRecoverablePacketLossAtHighBw);
   CheckDecision(controller.get(), true, kEnablingRecoverablePacketLossAtHighBw);
 }
 
@@ -215,9 +212,8 @@ TEST(FecControllerRplrBasedTest, MaintainFecOffForHighBandwidth) {
   auto controller = CreateFecControllerRplrBased(false);
   constexpr float kRecoverablePacketLoss =
       kEnablingRecoverablePacketLossAtHighBw * 0.99f;
-  UpdateNetworkMetrics(controller.get(),
-                       rtc::Optional<int>(kEnablingBandwidthHigh),
-                       rtc::Optional<float>(kRecoverablePacketLoss));
+  UpdateNetworkMetrics(controller.get(), kEnablingBandwidthHigh,
+                       kRecoverablePacketLoss);
   CheckDecision(controller.get(), false, kRecoverablePacketLoss);
 }
 
@@ -228,8 +224,8 @@ TEST(FecControllerRplrBasedTest, EnableFecForMediumBandwidth) {
        kEnablingRecoverablePacketLossAtHighBw) / 2.0;
   UpdateNetworkMetrics(
       controller.get(),
-      rtc::Optional<int>((kEnablingBandwidthHigh + kEnablingBandwidthLow) / 2),
-      rtc::Optional<float>(kRecoverablePacketLoss));
+      (kEnablingBandwidthHigh + kEnablingBandwidthLow) / 2,
+      kRecoverablePacketLoss);
   CheckDecision(controller.get(), true, kRecoverablePacketLoss);
 }
 
@@ -238,18 +234,16 @@ TEST(FecControllerRplrBasedTest, MaintainFecOffForMediumBandwidth) {
   constexpr float kRecoverablePacketLoss =
       kEnablingRecoverablePacketLossAtLowBw * 0.49f +
       kEnablingRecoverablePacketLossAtHighBw * 0.51f;
-  UpdateNetworkMetrics(
-      controller.get(),
-      rtc::Optional<int>((kEnablingBandwidthHigh + kEnablingBandwidthLow) / 2),
-      rtc::Optional<float>(kRecoverablePacketLoss));
+  UpdateNetworkMetrics(controller.get(),
+                       (kEnablingBandwidthHigh + kEnablingBandwidthLow) / 2,
+                       kRecoverablePacketLoss);
   CheckDecision(controller.get(), false, kRecoverablePacketLoss);
 }
 
 TEST(FecControllerRplrBasedTest, EnableFecForLowBandwidth) {
   auto controller = CreateFecControllerRplrBased(false);
-  UpdateNetworkMetrics(
-      controller.get(), rtc::Optional<int>(kEnablingBandwidthLow),
-      rtc::Optional<float>(kEnablingRecoverablePacketLossAtLowBw));
+  UpdateNetworkMetrics(controller.get(), kEnablingBandwidthLow,
+                       kEnablingRecoverablePacketLossAtLowBw);
   CheckDecision(controller.get(), true, kEnablingRecoverablePacketLossAtLowBw);
 }
 
@@ -257,9 +251,8 @@ TEST(FecControllerRplrBasedTest, MaintainFecOffForLowBandwidth) {
   auto controller = CreateFecControllerRplrBased(false);
   constexpr float kRecoverablePacketLoss =
       kEnablingRecoverablePacketLossAtLowBw * 0.99f;
-  UpdateNetworkMetrics(controller.get(),
-                       rtc::Optional<int>(kEnablingBandwidthLow),
-                       rtc::Optional<float>(kRecoverablePacketLoss));
+  UpdateNetworkMetrics(controller.get(), kEnablingBandwidthLow,
+                       kRecoverablePacketLoss);
   CheckDecision(controller.get(), false, kRecoverablePacketLoss);
 }
 
@@ -267,9 +260,7 @@ TEST(FecControllerRplrBasedTest, MaintainFecOffForVeryLowBandwidth) {
   auto controller = CreateFecControllerRplrBased(false);
   // Below |kEnablingBandwidthLow|, no recoverable packet loss fraction can
   // cause FEC to turn on.
-  UpdateNetworkMetrics(controller.get(),
-                       rtc::Optional<int>(kEnablingBandwidthLow - 1),
-                       rtc::Optional<float>(1.0));
+  UpdateNetworkMetrics(controller.get(), kEnablingBandwidthLow - 1, 1.0);
   CheckDecision(controller.get(), false, 1.0);
 }
 
@@ -277,18 +268,16 @@ TEST(FecControllerRplrBasedTest, DisableFecForHighBandwidth) {
   auto controller = CreateFecControllerRplrBased(true);
   constexpr float kRecoverablePacketLoss =
       kDisablingRecoverablePacketLossAtHighBw - kEpsilon;
-  UpdateNetworkMetrics(controller.get(),
-                       rtc::Optional<int>(kDisablingBandwidthHigh),
-                       rtc::Optional<float>(kRecoverablePacketLoss));
+  UpdateNetworkMetrics(controller.get(), kDisablingBandwidthHigh,
+                       kRecoverablePacketLoss);
   CheckDecision(controller.get(), false, kRecoverablePacketLoss);
 }
 
 TEST(FecControllerRplrBasedTest, MaintainFecOnForHighBandwidth) {
   // Note: Disabling happens when the value is strictly below the threshold.
   auto controller = CreateFecControllerRplrBased(true);
-  UpdateNetworkMetrics(
-      controller.get(), rtc::Optional<int>(kDisablingBandwidthHigh),
-      rtc::Optional<float>(kDisablingRecoverablePacketLossAtHighBw));
+  UpdateNetworkMetrics(controller.get(), kDisablingBandwidthHigh,
+                       kDisablingRecoverablePacketLossAtHighBw);
   CheckDecision(controller.get(), true,
                 kDisablingRecoverablePacketLossAtHighBw);
 }
@@ -300,9 +289,8 @@ TEST(FecControllerRplrBasedTest, DisableFecOnMediumBandwidth) {
         kDisablingRecoverablePacketLossAtHighBw) / 2.0f) - kEpsilon;
   UpdateNetworkMetrics(
       controller.get(),
-      rtc::Optional<int>((kDisablingBandwidthHigh + kDisablingBandwidthLow) /
-                         2),
-      rtc::Optional<float>(kRecoverablePacketLoss));
+      (kDisablingBandwidthHigh + kDisablingBandwidthLow) / 2,
+      kRecoverablePacketLoss);
   CheckDecision(controller.get(), false, kRecoverablePacketLoss);
 }
 
@@ -311,10 +299,9 @@ TEST(FecControllerRplrBasedTest, MaintainFecOnForMediumBandwidth) {
   constexpr float kRecoverablePacketLoss =
       kDisablingRecoverablePacketLossAtLowBw * 0.51f +
       kDisablingRecoverablePacketLossAtHighBw * 0.49f - kEpsilon;
-  UpdateNetworkMetrics(
-      controller.get(),
-      rtc::Optional<int>((kEnablingBandwidthHigh + kDisablingBandwidthLow) / 2),
-      rtc::Optional<float>(kRecoverablePacketLoss));
+  UpdateNetworkMetrics(controller.get(),
+                       (kEnablingBandwidthHigh + kDisablingBandwidthLow) / 2,
+                       kRecoverablePacketLoss);
   CheckDecision(controller.get(), true, kRecoverablePacketLoss);
 }
 
@@ -322,9 +309,8 @@ TEST(FecControllerRplrBasedTest, DisableFecForLowBandwidth) {
   auto controller = CreateFecControllerRplrBased(true);
   constexpr float kRecoverablePacketLoss =
       kDisablingRecoverablePacketLossAtLowBw - kEpsilon;
-  UpdateNetworkMetrics(controller.get(),
-                       rtc::Optional<int>(kDisablingBandwidthLow),
-                       rtc::Optional<float>(kRecoverablePacketLoss));
+  UpdateNetworkMetrics(controller.get(), kDisablingBandwidthLow,
+                       kRecoverablePacketLoss);
   CheckDecision(controller.get(), false, kRecoverablePacketLoss);
 }
 
@@ -332,9 +318,7 @@ TEST(FecControllerRplrBasedTest, DisableFecForVeryLowBandwidth) {
   auto controller = CreateFecControllerRplrBased(true);
   // Below |kEnablingBandwidthLow|, any recoverable packet loss fraction can
   // cause FEC to turn off.
-  UpdateNetworkMetrics(controller.get(),
-                       rtc::Optional<int>(kDisablingBandwidthLow - 1),
-                       rtc::Optional<float>(1.0));
+  UpdateNetworkMetrics(controller.get(), kDisablingBandwidthLow - 1, 1.0);
   CheckDecision(controller.get(), false, 1.0);
 }
 
@@ -350,31 +334,24 @@ TEST(FecControllerRplrBasedTest, CheckBehaviorOnChangingNetworkMetrics) {
   //             |---------5-------> bandwidth
 
   auto controller = CreateFecControllerRplrBased(true);
-  UpdateNetworkMetrics(controller.get(),
-                       rtc::Optional<int>(kDisablingBandwidthLow - 1),
-                       rtc::Optional<float>(1.0));
+  UpdateNetworkMetrics(controller.get(), kDisablingBandwidthLow - 1, 1.0);
   CheckDecision(controller.get(), false, 1.0);
 
-  UpdateNetworkMetrics(
-      controller.get(), rtc::Optional<int>(kEnablingBandwidthLow),
-      rtc::Optional<float>(kEnablingRecoverablePacketLossAtLowBw * 0.99f));
+  UpdateNetworkMetrics(controller.get(), kEnablingBandwidthLow,
+                       kEnablingRecoverablePacketLossAtLowBw * 0.99f);
   CheckDecision(controller.get(), false,
                 kEnablingRecoverablePacketLossAtLowBw * 0.99f);
 
-  UpdateNetworkMetrics(
-      controller.get(), rtc::Optional<int>(kEnablingBandwidthHigh),
-      rtc::Optional<float>(kEnablingRecoverablePacketLossAtHighBw));
+  UpdateNetworkMetrics(controller.get(), kEnablingBandwidthHigh,
+                       kEnablingRecoverablePacketLossAtHighBw);
   CheckDecision(controller.get(), true, kEnablingRecoverablePacketLossAtHighBw);
 
-  UpdateNetworkMetrics(
-      controller.get(), rtc::Optional<int>(kDisablingBandwidthHigh),
-      rtc::Optional<float>(kDisablingRecoverablePacketLossAtHighBw));
+  UpdateNetworkMetrics(controller.get(), kDisablingBandwidthHigh,
+                       kDisablingRecoverablePacketLossAtHighBw);
   CheckDecision(controller.get(), true,
                 kDisablingRecoverablePacketLossAtHighBw);
 
-  UpdateNetworkMetrics(controller.get(),
-                       rtc::Optional<int>(kDisablingBandwidthHigh + 1),
-                       rtc::Optional<float>(0.0));
+  UpdateNetworkMetrics(controller.get(), kDisablingBandwidthHigh + 1, 0.0);
   CheckDecision(controller.get(), false, 0.0);
 }
 
@@ -403,30 +380,23 @@ TEST(FecControllerRplrBasedTest, CheckBehaviorOnSpecialCurves) {
           kDisablingBandwidthLow, kDisablingRecoverablePacketLossAtLowBw,
           kDisablingBandwidthHigh, kDisablingRecoverablePacketLossAtHighBw)));
 
-  UpdateNetworkMetrics(&controller,
-                       rtc::Optional<int>(kDisablingBandwidthLow - 1),
-                       rtc::Optional<float>(1.0));
+  UpdateNetworkMetrics(&controller, kDisablingBandwidthLow - 1, 1.0);
   CheckDecision(&controller, false, 1.0);
 
-  UpdateNetworkMetrics(
-      &controller, rtc::Optional<int>(kEnablingBandwidthLow),
-      rtc::Optional<float>(kEnablingRecoverablePacketLossAtHighBw * 0.99f));
+  UpdateNetworkMetrics(&controller, kEnablingBandwidthLow,
+                       kEnablingRecoverablePacketLossAtHighBw * 0.99f);
   CheckDecision(&controller, false,
                 kEnablingRecoverablePacketLossAtHighBw * 0.99f);
 
-  UpdateNetworkMetrics(
-      &controller, rtc::Optional<int>(kEnablingBandwidthHigh),
-      rtc::Optional<float>(kEnablingRecoverablePacketLossAtHighBw));
+  UpdateNetworkMetrics(&controller, kEnablingBandwidthHigh,
+                       kEnablingRecoverablePacketLossAtHighBw);
   CheckDecision(&controller, true, kEnablingRecoverablePacketLossAtHighBw);
 
-  UpdateNetworkMetrics(
-      &controller, rtc::Optional<int>(kDisablingBandwidthHigh),
-      rtc::Optional<float>(kDisablingRecoverablePacketLossAtHighBw));
+  UpdateNetworkMetrics(&controller, kDisablingBandwidthHigh,
+                       kDisablingRecoverablePacketLossAtHighBw);
   CheckDecision(&controller, true, kDisablingRecoverablePacketLossAtHighBw);
 
-  UpdateNetworkMetrics(&controller,
-                       rtc::Optional<int>(kDisablingBandwidthHigh + 1),
-                       rtc::Optional<float>(0.0));
+  UpdateNetworkMetrics(&controller, kDisablingBandwidthHigh + 1, 0.0);
   CheckDecision(&controller, false, 0.0);
 }
 
@@ -559,5 +529,4 @@ TEST(FecControllerRplrBasedDeathTest, InvalidConfig) {
       "Check failed");
 }
 #endif
-
 }  // namespace webrtc