Convert QUIC non-feature flags to the old syntax, for consistency.

net/quic/core/congestion_control/bbr_sender_test.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/core/congestion_control/bbr_sender.h"
 
 #include <algorithm>
 #include <map>
 #include <memory>
 
@@ skipping 332 matching lines @@
   // The margin here is high, because the aggregation greatly increases
   // smoothed rtt.
   EXPECT_GE(kTestRtt * 4.5, rtt_stats_->smoothed_rtt());
   ExpectApproxEq(kTestRtt, rtt_stats_->min_rtt(), 0.1f);
 }
 
 // Test a simple long data transfer with 2 rtts of aggregation.
 TEST_F(BbrSenderTest, SimpleTransferAckDecimation) {
   FLAGS_quic_reloadable_flag_quic_bbr_ack_aggregation_bytes = true;
   // Decrease the CWND gain so extra CWND is required with stretch acks.
-  SetQuicFlag(&FLAGS_quic_bbr_cwnd_gain, 1.0);
+  FLAGS_quic_bbr_cwnd_gain = 1.0;
   sender_ = new BbrSender(
       rtt_stats_,
       QuicSentPacketManagerPeer::GetUnackedPacketMap(
           QuicConnectionPeer::GetSentPacketManager(bbr_sender_.connection())),
       kInitialCongestionWindowPackets, kDefaultMaxCongestionWindowPackets,
       &random_);
   QuicConnectionPeer::SetSendAlgorithm(bbr_sender_.connection(), sender_);
   // Enable Ack Decimation on the receiver.
   QuicConnectionPeer::SetAckMode(receiver_.connection(),
                                  QuicConnection::AckMode::ACK_DECIMATION);
@@ skipping 16 matching lines @@
   // smoothed rtt.
   EXPECT_GE(kTestRtt * 2, rtt_stats_->smoothed_rtt());
   ExpectApproxEq(kTestRtt, rtt_stats_->min_rtt(), 0.1f);
 }
 
 TEST_F(BbrSenderTest, SimpleTransferAckDecimationKeepSending) {
   FLAGS_quic_reloadable_flag_quic_bbr_ack_aggregation_bytes = false;
   FLAGS_quic_reloadable_flag_quic_bbr_add_tso_cwnd = true;
   FLAGS_quic_reloadable_flag_quic_bbr_keep_sending_at_recent_rate = true;
   // Decrease the CWND gain so extra CWND is required with stretch acks.
-  SetQuicFlag(&FLAGS_quic_bbr_cwnd_gain, 1.0);
+  FLAGS_quic_bbr_cwnd_gain = 1.0;
   sender_ = new BbrSender(
       rtt_stats_,
       QuicSentPacketManagerPeer::GetUnackedPacketMap(
           QuicConnectionPeer::GetSentPacketManager(bbr_sender_.connection())),
       kInitialCongestionWindowPackets, kDefaultMaxCongestionWindowPackets,
       &random_);
   QuicConnectionPeer::SetSendAlgorithm(bbr_sender_.connection(), sender_);
   // Enable Ack Decimation on the receiver.
   QuicConnectionPeer::SetAckMode(receiver_.connection(),
                                  QuicConnection::AckMode::ACK_DECIMATION);
@@ skipping 18 matching lines @@
   ExpectApproxEq(kTestRtt, rtt_stats_->min_rtt(), 0.1f);
 }
 
 // Test a simple long data transfer with 2 rtts of aggregation.
 TEST_F(BbrSenderTest,
        SimpleTransfer2RTTAggregationBytesWithIncreasedInflightLimit) {
   FLAGS_quic_reloadable_flag_quic_bbr_ack_aggregation_bytes = false;
   FLAGS_quic_reloadable_flag_quic_bbr_add_tso_cwnd = false;
   FLAGS_quic_reloadable_flag_quic_bbr_keep_sending_at_recent_rate = false;
   FLAGS_quic_reloadable_flag_quic_bbr_slow_recent_delivery = true;
-  SetQuicFlag(&FLAGS_quic_bbr_slow_delivery_threshold_multiplier, 0.5);
-  SetQuicFlag(&FLAGS_quic_bbr_slow_delivery_cwnd_gain, 4.0);
+  FLAGS_quic_bbr_slow_delivery_threshold_multiplier = 0.5;
+  FLAGS_quic_bbr_slow_delivery_cwnd_gain = 4.0;
   CreateDefaultSetup();
   // 2 RTTs of aggregation, with a max of 10kb.
   EnableAggregation(10 * 1024, 2 * kTestRtt);
 
   // Transfer 12MB.
   DoSimpleTransfer(12 * 1024 * 1024, QuicTime::Delta::FromSeconds(35));
   EXPECT_EQ(BbrSender::PROBE_BW, sender_->ExportDebugState().mode);
   // It's possible to read a bandwidth as much as 50% too high with aggregation.
   EXPECT_LE(kTestLinkBandwidth * 0.99f,
             sender_->ExportDebugState().max_bandwidth);
@@ skipping 367 matching lines @@
   sender_->ResumeConnectionState(params, false);
   EXPECT_EQ(kTestLinkBandwidth, sender_->ExportDebugState().max_bandwidth);
   EXPECT_EQ(kTestLinkBandwidth, sender_->BandwidthEstimate());
   ExpectApproxEq(kTestRtt, sender_->ExportDebugState().min_rtt, 0.01f);
 
   DriveOutOfStartup();
 }
 
 }  // namespace test
 }  // namespace net