gfe-relnote: In QUIC, default enable IETF loss detection with 1/4 RTT time threshold and adaptive packet threshold. Protected by existing gfe2_reloadable_flag_quic_default_on_ietf_loss_detection. PiperOrigin-RevId: 284345000 Change-Id: I83071dae7ac6c0e2598d23fe555716c26bc9730e
diff --git a/quic/core/congestion_control/general_loss_algorithm.cc b/quic/core/congestion_control/general_loss_algorithm.cc index 8798322..786f610 100644 --- a/quic/core/congestion_control/general_loss_algorithm.cc +++ b/quic/core/congestion_control/general_loss_algorithm.cc
@@ -18,15 +18,20 @@ // regardless of SRTT. Half of the minimum TLP, since the loss algorithm only // triggers when a nack has been receieved for the packet. static const size_t kMinLossDelayMs = 5; - -// Default fraction (1/8) of an RTT when doing IETF loss detection. -static const int kDefaultIetfLossDelayShift = 3; // Default fraction (1/16) of an RTT when doing adaptive loss detection. static const int kDefaultAdaptiveLossDelayShift = 4; } // namespace -GeneralLossAlgorithm::GeneralLossAlgorithm() : GeneralLossAlgorithm(kNack) {} +GeneralLossAlgorithm::GeneralLossAlgorithm() + : GeneralLossAlgorithm(GetDefaultLossDetectionType()) { + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + // TODO(fayang): Change defaults in GeneralLossAlgorithm(LossDetectionType + // loss_type) when deprecating quic_default_on_ietf_loss_detection. + set_reordering_shift(kDefaultLossDelayShift); + set_use_adaptive_reordering_threshold(true); + } +} GeneralLossAlgorithm::GeneralLossAlgorithm(LossDetectionType loss_type) : loss_detection_timeout_(QuicTime::Zero()), @@ -39,12 +44,16 @@ } void GeneralLossAlgorithm::SetLossDetectionType(LossDetectionType loss_type) { + DCHECK(!GetQuicRestartFlag(quic_default_on_ietf_loss_detection) || + loss_type == kIetfLossDetection); loss_detection_timeout_ = QuicTime::Zero(); loss_type_ = loss_type; if (loss_type == kAdaptiveTime) { reordering_shift_ = kDefaultAdaptiveLossDelayShift; } else if (loss_type == kIetfLossDetection) { - reordering_shift_ = kDefaultIetfLossDelayShift; + if (!GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + reordering_shift_ = kDefaultIetfLossDelayShift; + } } else { reordering_shift_ = kDefaultLossDelayShift; }
diff --git a/quic/core/congestion_control/general_loss_algorithm.h b/quic/core/congestion_control/general_loss_algorithm.h index fb85523..fb6af22 100644 --- a/quic/core/congestion_control/general_loss_algorithm.h +++ b/quic/core/congestion_control/general_loss_algorithm.h
@@ -66,8 +66,8 @@ return use_adaptive_reordering_threshold_; } - void enable_adaptive_reordering_threshold() { - use_adaptive_reordering_threshold_ = true; + void set_use_adaptive_reordering_threshold(bool value) { + use_adaptive_reordering_threshold_ = value; } bool use_adaptive_time_threshold() const { @@ -78,6 +78,8 @@ private: QuicTime loss_detection_timeout_; + // TODO(fayang): remove loss_type_ when deprecating + // quic_default_on_ietf_loss_detection. LossDetectionType loss_type_; // Fraction of a max(SRTT, latest_rtt) to permit reordering before declaring // loss. Fraction calculated by shifting max(SRTT, latest_rtt) to the right
diff --git a/quic/core/congestion_control/general_loss_algorithm_test.cc b/quic/core/congestion_control/general_loss_algorithm_test.cc index aaf9c7c..435e8ea 100644 --- a/quic/core/congestion_control/general_loss_algorithm_test.cc +++ b/quic/core/congestion_control/general_loss_algorithm_test.cc
@@ -138,7 +138,12 @@ packets_acked.push_back(AckedPacket( QuicPacketNumber(4), kMaxOutgoingPacketSize, QuicTime::Zero())); VerifyLosses(4, packets_acked, {1}); - EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout()); + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + EXPECT_EQ(clock_.Now() + 1.25 * rtt_stats_.smoothed_rtt(), + loss_algorithm_.GetLossTimeout()); + } else { + EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout()); + } } TEST_F(GeneralLossAlgorithmTest, EarlyRetransmit1Packet) { @@ -264,6 +269,9 @@ // NoFack loss detection tests. TEST_F(GeneralLossAlgorithmTest, LazyFackNackRetransmit1Packet) { + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + return; + } loss_algorithm_.SetLossDetectionType(kLazyFack); const size_t kNumSentPackets = 5; // Transmit 5 packets. @@ -295,6 +303,9 @@ // unacknowledged data. TEST_F(GeneralLossAlgorithmTest, LazyFackNoNackRetransmit1PacketWith1StretchAck) { + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + return; + } loss_algorithm_.SetLossDetectionType(kLazyFack); const size_t kNumSentPackets = 10; // Transmit 10 packets. @@ -326,6 +337,9 @@ // Ack a packet 3 packets ahead does not cause a retransmit. TEST_F(GeneralLossAlgorithmTest, LazyFackNackRetransmit1PacketSingleAck) { + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + return; + } loss_algorithm_.SetLossDetectionType(kLazyFack); const size_t kNumSentPackets = 10; // Transmit 10 packets. @@ -351,6 +365,9 @@ // Time-based loss detection tests. TEST_F(GeneralLossAlgorithmTest, NoLossFor500Nacks) { + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + return; + } loss_algorithm_.SetLossDetectionType(kTime); const size_t kNumSentPackets = 5; // Transmit 5 packets. @@ -370,6 +387,9 @@ } TEST_F(GeneralLossAlgorithmTest, NoLossUntilTimeout) { + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + return; + } loss_algorithm_.SetLossDetectionType(kTime); const size_t kNumSentPackets = 10; // Transmit 10 packets at 1/10th an RTT interval. @@ -396,6 +416,9 @@ } TEST_F(GeneralLossAlgorithmTest, NoLossWithoutNack) { + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + return; + } loss_algorithm_.SetLossDetectionType(kTime); const size_t kNumSentPackets = 10; // Transmit 10 packets at 1/10th an RTT interval. @@ -423,6 +446,9 @@ } TEST_F(GeneralLossAlgorithmTest, MultipleLossesAtOnce) { + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + return; + } loss_algorithm_.SetLossDetectionType(kTime); const size_t kNumSentPackets = 10; // Transmit 10 packets at once and then go forward an RTT. @@ -448,6 +474,9 @@ } TEST_F(GeneralLossAlgorithmTest, NoSpuriousLossesFromLargeReordering) { + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + return; + } loss_algorithm_.SetLossDetectionType(kTime); const size_t kNumSentPackets = 10; // Transmit 10 packets at once and then go forward an RTT. @@ -482,6 +511,9 @@ } TEST_F(GeneralLossAlgorithmTest, IncreaseThresholdUponSpuriousLoss) { + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + return; + } loss_algorithm_.SetLossDetectionType(kAdaptiveTime); EXPECT_EQ(4, loss_algorithm_.reordering_shift()); const size_t kNumSentPackets = 10; @@ -563,7 +595,7 @@ } TEST_F(GeneralLossAlgorithmTest, IncreaseReorderingThresholdUponSpuriousLoss) { - loss_algorithm_.enable_adaptive_reordering_threshold(); + loss_algorithm_.set_use_adaptive_reordering_threshold(true); for (size_t i = 1; i <= 4; ++i) { SendDataPacket(i); } @@ -627,6 +659,7 @@ TEST_F(GeneralLossAlgorithmTest, DefaultIetfLossDetection) { loss_algorithm_.SetLossDetectionType(kIetfLossDetection); + loss_algorithm_.set_reordering_shift(kDefaultIetfLossDelayShift); for (size_t i = 1; i <= 6; ++i) { SendDataPacket(i); }
diff --git a/quic/core/congestion_control/uber_loss_algorithm.cc b/quic/core/congestion_control/uber_loss_algorithm.cc index 4e7f07b..a72ba03 100644 --- a/quic/core/congestion_control/uber_loss_algorithm.cc +++ b/quic/core/congestion_control/uber_loss_algorithm.cc
@@ -8,7 +8,8 @@ namespace quic { -UberLossAlgorithm::UberLossAlgorithm() : UberLossAlgorithm(kNack) {} +UberLossAlgorithm::UberLossAlgorithm() + : UberLossAlgorithm(GetDefaultLossDetectionType()) {} UberLossAlgorithm::UberLossAlgorithm(LossDetectionType loss_type) : loss_type_(loss_type) { @@ -89,7 +90,13 @@ void UberLossAlgorithm::EnableAdaptiveReorderingThreshold() { for (int8_t i = INITIAL_DATA; i < NUM_PACKET_NUMBER_SPACES; ++i) { - general_loss_algorithms_[i].enable_adaptive_reordering_threshold(); + general_loss_algorithms_[i].set_use_adaptive_reordering_threshold(true); + } +} + +void UberLossAlgorithm::DisableAdaptiveReorderingThreshold() { + for (int8_t i = INITIAL_DATA; i < NUM_PACKET_NUMBER_SPACES; ++i) { + general_loss_algorithms_[i].set_use_adaptive_reordering_threshold(false); } }
diff --git a/quic/core/congestion_control/uber_loss_algorithm.h b/quic/core/congestion_control/uber_loss_algorithm.h index f922bba..2a530d2 100644 --- a/quic/core/congestion_control/uber_loss_algorithm.h +++ b/quic/core/congestion_control/uber_loss_algorithm.h
@@ -54,6 +54,9 @@ // Enable adaptive reordering threshold of all packet number spaces. void EnableAdaptiveReorderingThreshold(); + // Disable adaptive reordering threshold of all packet number spaces. + void DisableAdaptiveReorderingThreshold(); + // Enable adaptive time threshold of all packet number spaces. void EnableAdaptiveTimeThreshold();
diff --git a/quic/core/congestion_control/uber_loss_algorithm_test.cc b/quic/core/congestion_control/uber_loss_algorithm_test.cc index 79d0ff7..33e4167 100644 --- a/quic/core/congestion_control/uber_loss_algorithm_test.cc +++ b/quic/core/congestion_control/uber_loss_algorithm_test.cc
@@ -115,7 +115,12 @@ APPLICATION_DATA, QuicPacketNumber(4)); // No packet loss by acking 4. VerifyLosses(4, packets_acked_, std::vector<uint64_t>{}); - EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout()); + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + EXPECT_EQ(clock_.Now() + 1.25 * rtt_stats_.smoothed_rtt(), + loss_algorithm_.GetLossTimeout()); + } else { + EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout()); + } // Acking 6 causes 3 to be detected loss. AckPackets({6});
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc index 55f53eb..6ff097e 100644 --- a/quic/core/quic_connection.cc +++ b/quic/core/quic_connection.cc
@@ -303,7 +303,7 @@ random_generator_, &stats_, GetDefaultCongestionControlType(), - kNack), + GetDefaultLossDetectionType()), version_negotiated_(false), perspective_(perspective), connected_(true),
diff --git a/quic/core/quic_constants.h b/quic/core/quic_constants.h index 3264c15..0c6c4ff 100644 --- a/quic/core/quic_constants.h +++ b/quic/core/quic_constants.h
@@ -248,6 +248,9 @@ // packet is lost due to early retransmission by time based loss detection. static const int kDefaultLossDelayShift = 2; +// Default fraction (1/8) of an RTT when doing IETF loss detection. +static const int kDefaultIetfLossDelayShift = 3; + // Maximum number of retransmittable packets received before sending an ack. const QuicPacketCount kDefaultRetransmittablePacketsBeforeAck = 2; // Wait for up to 10 retransmittable packets before sending an ack.
diff --git a/quic/core/quic_sent_packet_manager.cc b/quic/core/quic_sent_packet_manager.cc index bd0343b..f4d3579 100644 --- a/quic/core/quic_sent_packet_manager.cc +++ b/quic/core/quic_sent_packet_manager.cc
@@ -250,29 +250,41 @@ use_new_rto_ = true; } // Configure loss detection. - if (config.HasClientRequestedIndependentOption(kTIME, perspective)) { - uber_loss_algorithm_.SetLossDetectionType(kTime); - } - if (config.HasClientRequestedIndependentOption(kATIM, perspective)) { - uber_loss_algorithm_.SetLossDetectionType(kAdaptiveTime); - } - if (config.HasClientRequestedIndependentOption(kLFAK, perspective)) { - uber_loss_algorithm_.SetLossDetectionType(kLazyFack); + if (!GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + if (config.HasClientRequestedIndependentOption(kTIME, perspective)) { + uber_loss_algorithm_.SetLossDetectionType(kTime); + } + if (config.HasClientRequestedIndependentOption(kATIM, perspective)) { + uber_loss_algorithm_.SetLossDetectionType(kAdaptiveTime); + } + if (config.HasClientRequestedIndependentOption(kLFAK, perspective)) { + uber_loss_algorithm_.SetLossDetectionType(kLazyFack); + } } if (GetQuicReloadableFlag(quic_enable_ietf_loss_detection)) { if (config.HasClientRequestedIndependentOption(kILD0, perspective)) { QUIC_RELOADABLE_FLAG_COUNT_N(quic_enable_ietf_loss_detection, 1, 5); uber_loss_algorithm_.SetLossDetectionType(kIetfLossDetection); + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + uber_loss_algorithm_.SetReorderingShift(kDefaultIetfLossDelayShift); + uber_loss_algorithm_.DisableAdaptiveReorderingThreshold(); + } } if (config.HasClientRequestedIndependentOption(kILD1, perspective)) { QUIC_RELOADABLE_FLAG_COUNT_N(quic_enable_ietf_loss_detection, 2, 5); uber_loss_algorithm_.SetLossDetectionType(kIetfLossDetection); uber_loss_algorithm_.SetReorderingShift(kDefaultLossDelayShift); + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + uber_loss_algorithm_.DisableAdaptiveReorderingThreshold(); + } } if (config.HasClientRequestedIndependentOption(kILD2, perspective)) { QUIC_RELOADABLE_FLAG_COUNT_N(quic_enable_ietf_loss_detection, 3, 5); uber_loss_algorithm_.SetLossDetectionType(kIetfLossDetection); uber_loss_algorithm_.EnableAdaptiveReorderingThreshold(); + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + uber_loss_algorithm_.SetReorderingShift(kDefaultIetfLossDelayShift); + } } if (config.HasClientRequestedIndependentOption(kILD3, perspective)) { QUIC_RELOADABLE_FLAG_COUNT_N(quic_enable_ietf_loss_detection, 4, 5);
diff --git a/quic/core/quic_sent_packet_manager_test.cc b/quic/core/quic_sent_packet_manager_test.cc index 8dd0c30..fe7a81f 100644 --- a/quic/core/quic_sent_packet_manager_test.cc +++ b/quic/core/quic_sent_packet_manager_test.cc
@@ -91,7 +91,7 @@ QuicRandom::GetInstance(), &stats_, kCubicBytes, - kNack), + GetDefaultLossDetectionType()), send_algorithm_(new StrictMock<MockSendAlgorithm>), network_change_visitor_(new StrictMock<MockNetworkChangeVisitor>) { QuicSentPacketManagerPeer::SetSendAlgorithm(&manager_, send_algorithm_); @@ -470,7 +470,13 @@ clock_.AdvanceTime(rtt); // Next, NACK packet 2 three times. - ExpectAck(3); + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false)); + EXPECT_CALL(notifier_, OnFrameLost(_)).Times(1); + ExpectAckAndLoss(true, 3, 2); + } else { + ExpectAck(3); + } manager_.OnAckFrameStart(QuicPacketNumber(3), QuicTime::Delta::Infinite(), clock_.Now()); manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(4)); @@ -488,12 +494,16 @@ manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(3), ENCRYPTION_INITIAL)); - ExpectAckAndLoss(true, 5, 2); - // Frames in all packets are acked. - EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false)); - // Notify session that stream frame in packet 2 gets lost although it is - // not outstanding. - EXPECT_CALL(notifier_, OnFrameLost(_)).Times(1); + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + ExpectAck(5); + } else { + // Frames in all packets are acked. + EXPECT_CALL(notifier_, IsFrameOutstanding(_)).WillRepeatedly(Return(false)); + // Notify session that stream frame in packet 2 gets lost although it is + // not outstanding. + EXPECT_CALL(notifier_, OnFrameLost(_)).Times(1); + ExpectAckAndLoss(true, 5, 2); + } manager_.OnAckFrameStart(QuicPacketNumber(5), QuicTime::Delta::Infinite(), clock_.Now()); manager_.OnAckRange(QuicPacketNumber(3), QuicPacketNumber(6)); @@ -1598,14 +1608,15 @@ // Ack a packet before the first RTO and ensure the RTO timeout returns to the // original value and OnRetransmissionTimeout is not called or reverted. - ExpectAck(2); + uint64_t acked[] = {1, 2}; + ExpectAcksAndLosses(true, acked, QUIC_ARRAYSIZE(acked), nullptr, 0); manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(), clock_.Now()); - manager_.OnAckRange(QuicPacketNumber(2), QuicPacketNumber(3)); + manager_.OnAckRange(QuicPacketNumber(1), QuicPacketNumber(3)); EXPECT_EQ(PACKETS_NEWLY_ACKED, manager_.OnAckFrameEnd(clock_.Now(), QuicPacketNumber(1), ENCRYPTION_INITIAL)); - EXPECT_EQ(5 * kDefaultLength, manager_.GetBytesInFlight()); + EXPECT_EQ(4 * kDefaultLength, manager_.GetBytesInFlight()); // Wait 2RTTs from now for the RTO, since it's the max of the RTO time // and the TLP time. In production, there would always be two TLP's first. @@ -1743,6 +1754,9 @@ } TEST_F(QuicSentPacketManagerTest, NegotiateTimeLossDetectionFromOptions) { + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + return; + } EXPECT_EQ(kNack, QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_) ->GetLossDetectionType()); @@ -1760,8 +1774,20 @@ TEST_F(QuicSentPacketManagerTest, NegotiateIetfLossDetectionFromOptions) { SetQuicReloadableFlag(quic_enable_ietf_loss_detection, true); - EXPECT_EQ(kNack, QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_) - ->GetLossDetectionType()); + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + EXPECT_EQ(kIetfLossDetection, + QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_) + ->GetLossDetectionType()); + EXPECT_TRUE(QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled( + &manager_)); + EXPECT_FALSE( + QuicSentPacketManagerPeer::AdaptiveTimeThresholdEnabled(&manager_)); + EXPECT_EQ(kDefaultLossDelayShift, + QuicSentPacketManagerPeer::GetReorderingShift(&manager_)); + } else { + EXPECT_EQ(kNack, QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_) + ->GetLossDetectionType()); + } QuicConfig config; QuicTagVector options; @@ -1782,8 +1808,20 @@ TEST_F(QuicSentPacketManagerTest, NegotiateIetfLossDetectionOneFourthRttFromOptions) { SetQuicReloadableFlag(quic_enable_ietf_loss_detection, true); - EXPECT_EQ(kNack, QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_) - ->GetLossDetectionType()); + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + EXPECT_EQ(kIetfLossDetection, + QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_) + ->GetLossDetectionType()); + EXPECT_TRUE(QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled( + &manager_)); + EXPECT_FALSE( + QuicSentPacketManagerPeer::AdaptiveTimeThresholdEnabled(&manager_)); + EXPECT_EQ(kDefaultLossDelayShift, + QuicSentPacketManagerPeer::GetReorderingShift(&manager_)); + } else { + EXPECT_EQ(kNack, QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_) + ->GetLossDetectionType()); + } QuicConfig config; QuicTagVector options; @@ -1805,10 +1843,22 @@ TEST_F(QuicSentPacketManagerTest, NegotiateIetfLossDetectionAdaptiveReorderingThreshold) { SetQuicReloadableFlag(quic_enable_ietf_loss_detection, true); - EXPECT_EQ(kNack, QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_) - ->GetLossDetectionType()); - EXPECT_FALSE( - QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled(&manager_)); + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + EXPECT_EQ(kIetfLossDetection, + QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_) + ->GetLossDetectionType()); + EXPECT_TRUE(QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled( + &manager_)); + EXPECT_FALSE( + QuicSentPacketManagerPeer::AdaptiveTimeThresholdEnabled(&manager_)); + EXPECT_EQ(kDefaultLossDelayShift, + QuicSentPacketManagerPeer::GetReorderingShift(&manager_)); + } else { + EXPECT_EQ(kNack, QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_) + ->GetLossDetectionType()); + EXPECT_FALSE(QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled( + &manager_)); + } QuicConfig config; QuicTagVector options; @@ -1829,10 +1879,22 @@ TEST_F(QuicSentPacketManagerTest, NegotiateIetfLossDetectionAdaptiveReorderingThreshold2) { SetQuicReloadableFlag(quic_enable_ietf_loss_detection, true); - EXPECT_EQ(kNack, QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_) - ->GetLossDetectionType()); - EXPECT_FALSE( - QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled(&manager_)); + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + EXPECT_EQ(kIetfLossDetection, + QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_) + ->GetLossDetectionType()); + EXPECT_TRUE(QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled( + &manager_)); + EXPECT_FALSE( + QuicSentPacketManagerPeer::AdaptiveTimeThresholdEnabled(&manager_)); + EXPECT_EQ(kDefaultLossDelayShift, + QuicSentPacketManagerPeer::GetReorderingShift(&manager_)); + } else { + EXPECT_EQ(kNack, QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_) + ->GetLossDetectionType()); + EXPECT_FALSE(QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled( + &manager_)); + } QuicConfig config; QuicTagVector options; @@ -1841,7 +1903,6 @@ EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)); EXPECT_CALL(*network_change_visitor_, OnCongestionChange()); manager_.SetFromConfig(config); - EXPECT_EQ(kIetfLossDetection, QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_) ->GetLossDetectionType()); @@ -1854,12 +1915,24 @@ TEST_F(QuicSentPacketManagerTest, NegotiateIetfLossDetectionAdaptiveReorderingAndTimeThreshold) { SetQuicReloadableFlag(quic_enable_ietf_loss_detection, true); - EXPECT_EQ(kNack, QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_) - ->GetLossDetectionType()); - EXPECT_FALSE( - QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled(&manager_)); - EXPECT_FALSE( - QuicSentPacketManagerPeer::AdaptiveTimeThresholdEnabled(&manager_)); + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + EXPECT_EQ(kIetfLossDetection, + QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_) + ->GetLossDetectionType()); + EXPECT_TRUE(QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled( + &manager_)); + EXPECT_FALSE( + QuicSentPacketManagerPeer::AdaptiveTimeThresholdEnabled(&manager_)); + EXPECT_EQ(kDefaultLossDelayShift, + QuicSentPacketManagerPeer::GetReorderingShift(&manager_)); + } else { + EXPECT_EQ(kNack, QuicSentPacketManagerPeer::GetLossAlgorithm(&manager_) + ->GetLossDetectionType()); + EXPECT_FALSE(QuicSentPacketManagerPeer::AdaptiveReorderingThresholdEnabled( + &manager_)); + EXPECT_FALSE( + QuicSentPacketManagerPeer::AdaptiveTimeThresholdEnabled(&manager_)); + } QuicConfig config; QuicTagVector options;
diff --git a/quic/core/quic_types.h b/quic/core/quic_types.h index 23cbe7a..b14e513 100644 --- a/quic/core/quic_types.h +++ b/quic/core/quic_types.h
@@ -404,6 +404,16 @@ kIetfLossDetection, // IETF style loss detection. }; +// TODO(fayang): Remove this when deprecating +// quic_default_on_ietf_loss_detection. +inline LossDetectionType GetDefaultLossDetectionType() { + if (GetQuicRestartFlag(quic_default_on_ietf_loss_detection)) { + QUIC_RESTART_FLAG_COUNT(quic_default_on_ietf_loss_detection); + return kIetfLossDetection; + } + return kNack; +} + // EncryptionLevel enumerates the stages of encryption that a QUIC connection // progresses through. When retransmitting a packet, the encryption level needs // to be specified so that it is retransmitted at a level which the peer can