Deprecate gfe2_reloadable_flag_quic_use_idle_network_detector. PiperOrigin-RevId: 318854988 Change-Id: I01bbf3eb76ca1cb2800a2db4ae274e23381e69b0
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc index 3544457..50a42f5 100644 --- a/quic/core/quic_connection.cc +++ b/quic/core/quic_connection.cc
@@ -109,19 +109,6 @@ QuicConnection* connection_; }; -class TimeoutAlarmDelegate : public QuicAlarm::Delegate { - public: - explicit TimeoutAlarmDelegate(QuicConnection* connection) - : connection_(connection) {} - TimeoutAlarmDelegate(const TimeoutAlarmDelegate&) = delete; - TimeoutAlarmDelegate& operator=(const TimeoutAlarmDelegate&) = delete; - - void OnAlarm() override { connection_->CheckForTimeout(); } - - private: - QuicConnection* connection_; -}; - class PingAlarmDelegate : public QuicAlarm::Delegate { public: explicit PingAlarmDelegate(QuicConnection* connection) @@ -265,9 +252,6 @@ send_alarm_( alarm_factory_->CreateAlarm(arena_.New<SendAlarmDelegate>(this), &arena_)), - timeout_alarm_( - alarm_factory_->CreateAlarm(arena_.New<TimeoutAlarmDelegate>(this), - &arena_)), ping_alarm_( alarm_factory_->CreateAlarm(arena_.New<PingAlarmDelegate>(this), &arena_)), @@ -280,11 +264,7 @@ visitor_(nullptr), debug_visitor_(nullptr), packet_creator_(server_connection_id_, &framer_, random_generator_, this), - idle_network_timeout_(QuicTime::Delta::Infinite()), - handshake_timeout_(QuicTime::Delta::Infinite()), - time_of_first_packet_sent_after_receiving_(QuicTime::Zero()), time_of_last_received_packet_(clock_->ApproximateNow()), - time_of_last_decryptable_packet_(time_of_last_received_packet_), sent_packet_manager_(perspective, clock_, random_generator_, @@ -1031,11 +1011,7 @@ // Address is validated by successfully processing a HANDSHAKE packet. address_validated_ = true; } - if (use_idle_network_detector_) { - idle_network_detector_.OnPacketReceived(time_of_last_received_packet_); - } else { - time_of_last_decryptable_packet_ = time_of_last_received_packet_; - } + idle_network_detector_.OnPacketReceived(time_of_last_received_packet_); visitor_->OnPacketDecrypted(level); } @@ -1110,7 +1086,7 @@ // frames, since the processing may result in sending a bundled ack. uber_received_packet_manager_.RecordPacketReceived( last_decrypted_packet_level_, last_header_, - GetTimeOfLastReceivedPacket()); + idle_network_detector_.time_of_last_received_packet()); DCHECK(connected_); return true; } @@ -1205,8 +1181,9 @@ return false; } processing_ack_frame_ = true; - sent_packet_manager_.OnAckFrameStart(largest_acked, ack_delay_time, - GetTimeOfLastReceivedPacket()); + sent_packet_manager_.OnAckFrameStart( + largest_acked, ack_delay_time, + idle_network_detector_.time_of_last_received_packet()); return true; } @@ -1252,8 +1229,8 @@ const bool one_rtt_packet_was_acked = sent_packet_manager_.one_rtt_packet_acked(); const AckResult ack_result = sent_packet_manager_.OnAckFrameEnd( - GetTimeOfLastReceivedPacket(), last_header_.packet_number, - last_decrypted_packet_level_); + idle_network_detector_.time_of_last_received_packet(), + last_header_.packet_number, last_decrypted_packet_level_); if (ack_result != PACKETS_NEWLY_ACKED && ack_result != NO_PACKETS_NEWLY_ACKED) { // Error occurred (e.g., this ACK tries to ack packets in wrong packet @@ -1526,7 +1503,8 @@ UpdatePacketContent(NOT_PADDED_PING); if (debug_visitor_ != nullptr) { - debug_visitor_->OnWindowUpdateFrame(frame, GetTimeOfLastReceivedPacket()); + debug_visitor_->OnWindowUpdateFrame( + frame, idle_network_detector_.time_of_last_received_packet()); } QUIC_DVLOG(1) << ENDPOINT << "WINDOW_UPDATE_FRAME received " << frame; MaybeUpdateAckTimeout(); @@ -1696,7 +1674,8 @@ if (!should_last_packet_instigate_acks_) { uber_received_packet_manager_.MaybeUpdateAckTimeout( should_last_packet_instigate_acks_, last_decrypted_packet_level_, - last_header_.packet_number, GetTimeOfLastReceivedPacket(), + last_header_.packet_number, + idle_network_detector_.time_of_last_received_packet(), clock_->ApproximateNow(), sent_packet_manager_.GetRttStats()); } @@ -2765,18 +2744,7 @@ blackhole_detector_.RestartDetection(GetPathDegradingDeadline(), GetNetworkBlackholeDeadline()); } - - if (use_idle_network_detector_) { - idle_network_detector_.OnPacketSent(packet_send_time); - QUIC_RELOADABLE_FLAG_COUNT_N(quic_use_idle_network_detector, 2, 6); - } else if (time_of_first_packet_sent_after_receiving_ < - GetTimeOfLastReceivedPacket()) { - // Update |time_of_first_packet_sent_after_receiving_| if this is the - // first packet sent after the last packet was received. If it were - // updated on every sent packet, then sending into a black hole might - // never timeout. - time_of_first_packet_sent_after_receiving_ = packet_send_time; - } + idle_network_detector_.OnPacketSent(packet_send_time); } MaybeSetMtuAlarm(packet_number); @@ -3496,14 +3464,10 @@ ping_alarm_->Cancel(); retransmission_alarm_->Cancel(); send_alarm_->Cancel(); - timeout_alarm_->Cancel(); mtu_discovery_alarm_->Cancel(); process_undecryptable_packets_alarm_->Cancel(); blackhole_detector_.StopDetection(); - if (use_idle_network_detector_) { - QUIC_RELOADABLE_FLAG_COUNT_N(quic_use_idle_network_detector, 3, 6); - idle_network_detector_.StopDetection(); - } + idle_network_detector_.StopDetection(); } QuicByteCount QuicConnection::max_packet_length() const { @@ -3532,85 +3496,7 @@ } else if (idle_timeout > QuicTime::Delta::FromSeconds(1)) { idle_timeout = idle_timeout - QuicTime::Delta::FromSeconds(1); } - if (use_idle_network_detector_) { - QUIC_RELOADABLE_FLAG_COUNT_N(quic_use_idle_network_detector, 4, 6); - idle_network_detector_.SetTimeouts(handshake_timeout, idle_timeout); - return; - } - handshake_timeout_ = handshake_timeout; - idle_network_timeout_ = idle_timeout; - - SetTimeoutAlarm(); -} - -void QuicConnection::CheckForTimeout() { - DCHECK(!use_idle_network_detector_); - QuicTime now = clock_->ApproximateNow(); - if (!handshake_timeout_.IsInfinite()) { - QuicTime::Delta connected_duration = now - stats_.connection_creation_time; - QUIC_DVLOG(1) << ENDPOINT - << "connection time: " << connected_duration.ToMicroseconds() - << " handshake timeout: " - << handshake_timeout_.ToMicroseconds(); - if (connected_duration >= handshake_timeout_) { - const std::string error_details = quiche::QuicheStrCat( - "Handshake timeout expired after ", - connected_duration.ToDebuggingValue(), - ". Timeout:", handshake_timeout_.ToDebuggingValue()); - QUIC_DVLOG(1) << ENDPOINT << error_details; - CloseConnection(QUIC_HANDSHAKE_TIMEOUT, error_details, - ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET); - return; - } - } - - QuicTime time_of_last_packet = - std::max(GetTimeOfLastReceivedPacket(), - time_of_first_packet_sent_after_receiving_); - - // |delta| can be < 0 as |now| is approximate time but |time_of_last_packet| - // is accurate time. However, this should not change the behavior of - // timeout handling. - QuicTime::Delta idle_duration = now - time_of_last_packet; - QUIC_DVLOG(1) << ENDPOINT << "last packet " - << time_of_last_packet.ToDebuggingValue() - << " now:" << now.ToDebuggingValue() - << " idle_duration:" << idle_duration.ToMicroseconds() - << " idle_network_timeout: " - << idle_network_timeout_.ToMicroseconds(); - if (idle_duration >= idle_network_timeout_) { - const std::string error_details = quiche::QuicheStrCat( - "No recent network activity after ", idle_duration.ToDebuggingValue(), - ". Timeout:", idle_network_timeout_.ToDebuggingValue()); - QUIC_DVLOG(1) << ENDPOINT << error_details; - if ((sent_packet_manager_.GetConsecutiveTlpCount() > 0 || - sent_packet_manager_.GetConsecutiveRtoCount() > 0 || - visitor_->ShouldKeepConnectionAlive())) { - CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT, error_details, - ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET); - } else { - CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT, error_details, - idle_timeout_connection_close_behavior_); - } - return; - } - - SetTimeoutAlarm(); -} - -void QuicConnection::SetTimeoutAlarm() { - DCHECK(!use_idle_network_detector_); - QuicTime time_of_last_packet = - std::max(GetTimeOfLastReceivedPacket(), - time_of_first_packet_sent_after_receiving_); - - QuicTime deadline = time_of_last_packet + idle_network_timeout_; - if (!handshake_timeout_.IsInfinite()) { - deadline = std::min(deadline, - stats_.connection_creation_time + handshake_timeout_); - } - - timeout_alarm_->Update(deadline, QuicTime::Delta::Zero()); + idle_network_detector_.SetTimeouts(handshake_timeout, idle_timeout); } void QuicConnection::SetPingAlarm() { @@ -4688,8 +4574,6 @@ } void QuicConnection::OnHandshakeTimeout() { - QUIC_RELOADABLE_FLAG_COUNT_N(quic_use_idle_network_detector, 5, 6); - DCHECK(use_idle_network_detector_); const QuicTime::Delta duration = clock_->ApproximateNow() - stats_.connection_creation_time; std::string error_details = quiche::QuicheStrCat( @@ -4706,8 +4590,6 @@ } void QuicConnection::OnIdleNetworkDetected() { - QUIC_RELOADABLE_FLAG_COUNT_N(quic_use_idle_network_detector, 6, 6); - DCHECK(use_idle_network_detector_); const QuicTime::Delta duration = clock_->ApproximateNow() - idle_network_detector_.last_network_activity_time(); @@ -4735,7 +4617,8 @@ should_last_packet_instigate_acks_ = true; uber_received_packet_manager_.MaybeUpdateAckTimeout( /*should_last_packet_instigate_acks=*/true, last_decrypted_packet_level_, - last_header_.packet_number, GetTimeOfLastReceivedPacket(), + last_header_.packet_number, + idle_network_detector_.time_of_last_received_packet(), clock_->ApproximateNow(), sent_packet_manager_.GetRttStats()); } @@ -4752,7 +4635,7 @@ return false; } // No path degrading detection before handshake completes. - if (!GetHandshakeTimeout().IsInfinite()) { + if (!idle_network_detector_.handshake_timeout().IsInfinite()) { return false; } return perspective_ == Perspective::IS_CLIENT && !is_path_degrading_; @@ -4779,27 +4662,11 @@ return IsHandshakeComplete(); } - if (!GetHandshakeTimeout().IsInfinite()) { + if (!idle_network_detector_.handshake_timeout().IsInfinite()) { return false; } return num_rtos_for_blackhole_detection_ > 0; } -QuicTime::Delta QuicConnection::GetHandshakeTimeout() const { - if (use_idle_network_detector_) { - return idle_network_detector_.handshake_timeout(); - } - return handshake_timeout_; -} - -QuicTime QuicConnection::GetTimeOfLastReceivedPacket() const { - if (use_idle_network_detector_) { - return idle_network_detector_.time_of_last_received_packet(); - } - DCHECK(time_of_last_decryptable_packet_ == time_of_last_received_packet_ || - !last_packet_decrypted_); - return time_of_last_decryptable_packet_; -} - #undef ENDPOINT // undef for jumbo builds } // namespace quic
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h index c0f722d..b3e44b3 100644 --- a/quic/core/quic_connection.h +++ b/quic/core/quic_connection.h
@@ -687,10 +687,6 @@ void SetNetworkTimeouts(QuicTime::Delta handshake_timeout, QuicTime::Delta idle_timeout); - // If the connection has timed out, this will close the connection. - // Otherwise, it will reschedule the timeout alarm. - void CheckForTimeout(); - // Called when the ping alarm fires. Causes a ping frame to be sent only // if the retransmission alarm is not running. void OnPingTimeout(); @@ -1172,9 +1168,6 @@ // sent if there are no outstanding packets. QuicPacketNumber GetLeastUnacked() const; - // Sets the timeout alarm to the appropriate value, if any. - void SetTimeoutAlarm(); - // Sets the ping alarm to the appropriate value, if any. void SetPingAlarm(); @@ -1314,10 +1307,6 @@ // Returns true if network blackhole should be detected. bool ShouldDetectBlackhole() const; - // Remove these two when deprecating quic_use_idle_network_detector. - QuicTime::Delta GetHandshakeTimeout() const; - QuicTime GetTimeOfLastReceivedPacket() const; - // Validate connection IDs used during the handshake. Closes the connection // on validation failure. bool ValidateConfigConnectionIds(const QuicConfig& config); @@ -1488,11 +1477,6 @@ // An alarm that is scheduled when the SentPacketManager requires a delay // before sending packets and fires when the packet may be sent. QuicArenaScopedPtr<QuicAlarm> send_alarm_; - // An alarm that is scheduled when the connection can still write and there - // may be more data to send. - // An alarm that fires when the connection may have timed out. - // TODO(fayang): Remove this when deprecating quic_use_idle_network_detector. - QuicArenaScopedPtr<QuicAlarm> timeout_alarm_; // An alarm that fires when a ping should be sent. QuicArenaScopedPtr<QuicAlarm> ping_alarm_; // An alarm that fires when an MTU probe should be sent. @@ -1506,33 +1490,13 @@ QuicPacketCreator packet_creator_; - // TODO(fayang): Remove these two when deprecating - // quic_use_idle_network_detector. - // Network idle time before this connection is closed. - QuicTime::Delta idle_network_timeout_; - // The connection will wait this long for the handshake to complete. - QuicTime::Delta handshake_timeout_; - // Statistics for this session. QuicConnectionStats stats_; - // Timestamps used for timeouts. - // The time of the first retransmittable packet that was sent after the most - // recently received packet. - // TODO(fayang): Remove time_of_first_packet_sent_after_receiving_ when - // deprecating quic_use_idle_network_detector. - QuicTime time_of_first_packet_sent_after_receiving_; // The time that a packet is received for this connection. Initialized to // connection creation time. // This does not indicate the packet was processed. QuicTime time_of_last_received_packet_; - // This gets set to time_of_last_received_packet_ when a packet gets - // decrypted. Please note, this is not necessarily the original receive time - // of this decrypt packet because connection can decryptable packet out of - // order. - // TODO(fayang): Remove time_of_last_decryptable_packet_ when - // deprecating quic_use_idle_network_detector. - QuicTime time_of_last_decryptable_packet_; // Sent packet manager which tracks the status of packets sent by this // connection and contains the send and receive algorithms to determine when @@ -1706,9 +1670,6 @@ // True if this connection supports handshake done frame. bool support_handshake_done_; - const bool use_idle_network_detector_ = - GetQuicReloadableFlag(quic_use_idle_network_detector); - const bool update_ack_alarm_in_send_all_pending_acks_ = GetQuicReloadableFlag(quic_update_ack_alarm_in_send_all_pending_acks);
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc index d8d3013..8b676fd 100644 --- a/quic/core/quic_connection_test.cc +++ b/quic/core/quic_connection_test.cc
@@ -903,12 +903,8 @@ } TestAlarmFactory::TestAlarm* GetTimeoutAlarm() { - if (GetQuicReloadableFlag(quic_use_idle_network_detector)) { - return reinterpret_cast<TestAlarmFactory::TestAlarm*>( - QuicConnectionPeer::GetIdleNetworkDetectorAlarm(this)); - } return reinterpret_cast<TestAlarmFactory::TestAlarm*>( - QuicConnectionPeer::GetTimeoutAlarm(this)); + QuicConnectionPeer::GetIdleNetworkDetectorAlarm(this)); } TestAlarmFactory::TestAlarm* GetMtuDiscoveryAlarm() { @@ -4807,9 +4803,6 @@ EXPECT_CALL(visitor_, OnConnectionClosed(_, _)).Times(0); QuicTime::Delta delay = initial_ddl - clock_.ApproximateNow(); clock_.AdvanceTime(delay); - if (!GetQuicReloadableFlag(quic_use_idle_network_detector)) { - connection_.GetTimeoutAlarm()->Fire(); - } // Verify the timeout alarm deadline is updated. EXPECT_TRUE(connection_.connected()); EXPECT_TRUE(connection_.GetTimeoutAlarm()->IsSet()); @@ -4898,10 +4891,6 @@ EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _)); ProcessAckPacket(&frame); - if (!GetQuicReloadableFlag(quic_use_idle_network_detector)) { - // Fire early to verify it wouldn't timeout yet. - connection_.GetTimeoutAlarm()->Fire(); - } EXPECT_TRUE(connection_.GetTimeoutAlarm()->IsSet()); EXPECT_TRUE(connection_.connected()); @@ -5643,12 +5632,8 @@ SendStreamDataToPeer( GetNthClientInitiatedStreamId(1, connection_.transport_version()), "foo", 0, FIN, nullptr); - if (GetQuicReloadableFlag(quic_use_idle_network_detector)) { - EXPECT_EQ(default_timeout + five_ms, - connection_.GetTimeoutAlarm()->deadline()); - } else { - EXPECT_EQ(default_timeout, connection_.GetTimeoutAlarm()->deadline()); - } + EXPECT_EQ(default_timeout + five_ms, + connection_.GetTimeoutAlarm()->deadline()); // Now send more data. This will not move the timeout because // no data has been received since the previous write. @@ -5656,20 +5641,13 @@ SendStreamDataToPeer( GetNthClientInitiatedStreamId(1, connection_.transport_version()), "foo", 3, FIN, nullptr); - if (GetQuicReloadableFlag(quic_use_idle_network_detector)) { - EXPECT_EQ(default_timeout + five_ms, - connection_.GetTimeoutAlarm()->deadline()); - } else { - EXPECT_EQ(default_timeout, connection_.GetTimeoutAlarm()->deadline()); - } + EXPECT_EQ(default_timeout + five_ms, + connection_.GetTimeoutAlarm()->deadline()); // The original alarm will fire. We should not time out because we had a // network event at t=5ms. The alarm will reregister. clock_.AdvanceTime(initial_idle_timeout - five_ms - five_ms); EXPECT_EQ(default_timeout, clock_.ApproximateNow()); - if (!GetQuicReloadableFlag(quic_use_idle_network_detector)) { - connection_.GetTimeoutAlarm()->Fire(); - } EXPECT_TRUE(connection_.GetTimeoutAlarm()->IsSet()); EXPECT_TRUE(connection_.connected()); EXPECT_EQ(default_timeout + five_ms, @@ -5717,12 +5695,8 @@ SendStreamDataToPeer( GetNthClientInitiatedStreamId(1, connection_.transport_version()), "foo", 0, FIN, nullptr); - if (GetQuicReloadableFlag(quic_use_idle_network_detector)) { - EXPECT_EQ(default_timeout + five_ms, - connection_.GetTimeoutAlarm()->deadline()); - } else { - EXPECT_EQ(default_timeout, connection_.GetTimeoutAlarm()->deadline()); - } + EXPECT_EQ(default_timeout + five_ms, + connection_.GetTimeoutAlarm()->deadline()); // Move forward 5 ms and receive a packet, which will move the timeout // forward 5 ms more (but will not reschedule the alarm). @@ -5751,9 +5725,6 @@ ASSERT_EQ(default_timeout.ToDebuggingValue(), clock_.Now().ToDebuggingValue()); EXPECT_EQ(default_timeout, clock_.Now()); - if (!GetQuicReloadableFlag(quic_use_idle_network_detector)) { - connection_.GetTimeoutAlarm()->Fire(); - } EXPECT_TRUE(connection_.GetTimeoutAlarm()->IsSet()); EXPECT_TRUE(connection_.connected()); ASSERT_EQ(final_timeout.ToDebuggingValue(), @@ -5813,12 +5784,8 @@ SendStreamDataToPeer( GetNthClientInitiatedStreamId(1, connection_.transport_version()), "foo", 0, FIN, nullptr); - if (GetQuicReloadableFlag(quic_use_idle_network_detector)) { - EXPECT_EQ(default_timeout + five_ms, - connection_.GetTimeoutAlarm()->deadline()); - } else { - EXPECT_EQ(default_timeout, connection_.GetTimeoutAlarm()->deadline()); - } + EXPECT_EQ(default_timeout + five_ms, + connection_.GetTimeoutAlarm()->deadline()); // Now send more data. This will not move the timeout because // no data has been received since the previous write. @@ -5826,20 +5793,13 @@ SendStreamDataToPeer( GetNthClientInitiatedStreamId(1, connection_.transport_version()), "foo", 3, FIN, nullptr); - if (GetQuicReloadableFlag(quic_use_idle_network_detector)) { - EXPECT_EQ(default_timeout + five_ms, - connection_.GetTimeoutAlarm()->deadline()); - } else { - EXPECT_EQ(default_timeout, connection_.GetTimeoutAlarm()->deadline()); - } + EXPECT_EQ(default_timeout + five_ms, + connection_.GetTimeoutAlarm()->deadline()); // The original alarm will fire. We should not time out because we had a // network event at t=5ms. The alarm will reregister. clock_.AdvanceTime(default_idle_timeout - five_ms - five_ms); EXPECT_EQ(default_timeout, clock_.ApproximateNow()); - if (!GetQuicReloadableFlag(quic_use_idle_network_detector)) { - connection_.GetTimeoutAlarm()->Fire(); - } EXPECT_TRUE(connection_.GetTimeoutAlarm()->IsSet()); EXPECT_TRUE(connection_.connected()); EXPECT_EQ(default_timeout + five_ms, @@ -5899,12 +5859,8 @@ SendStreamDataToPeer( GetNthClientInitiatedStreamId(1, connection_.transport_version()), "foo", 0, FIN, nullptr); - if (GetQuicReloadableFlag(quic_use_idle_network_detector)) { - EXPECT_EQ(default_timeout + five_ms, - connection_.GetTimeoutAlarm()->deadline()); - } else { - EXPECT_EQ(default_timeout, connection_.GetTimeoutAlarm()->deadline()); - } + EXPECT_EQ(default_timeout + five_ms, + connection_.GetTimeoutAlarm()->deadline()); // Retransmit the packet via tail loss probe. clock_.AdvanceTime(connection_.GetRetransmissionAlarm()->deadline() - @@ -5965,12 +5921,8 @@ SendStreamDataToPeer( GetNthClientInitiatedStreamId(1, connection_.transport_version()), "foo", 0, FIN, nullptr); - if (GetQuicReloadableFlag(quic_use_idle_network_detector)) { - EXPECT_EQ(default_timeout + five_ms, - connection_.GetTimeoutAlarm()->deadline()); - } else { - EXPECT_EQ(default_timeout, connection_.GetTimeoutAlarm()->deadline()); - } + EXPECT_EQ(default_timeout + five_ms, + connection_.GetTimeoutAlarm()->deadline()); // Indicate streams are still open. EXPECT_CALL(visitor_, ShouldKeepConnectionAlive()) @@ -6020,9 +5972,6 @@ // network event at t=5ms. The alarm will reregister. clock_.AdvanceTime(initial_idle_timeout - five_ms); EXPECT_EQ(default_timeout, clock_.ApproximateNow()); - if (!GetQuicReloadableFlag(quic_use_idle_network_detector)) { - connection_.GetTimeoutAlarm()->Fire(); - } EXPECT_TRUE(connection_.connected()); EXPECT_TRUE(connection_.GetTimeoutAlarm()->IsSet()); EXPECT_EQ(default_timeout + five_ms, @@ -6078,9 +6027,6 @@ // network event at t=5ms. The alarm will reregister. clock_.AdvanceTime(initial_idle_timeout - five_ms); EXPECT_EQ(default_timeout, clock_.ApproximateNow()); - if (!GetQuicReloadableFlag(quic_use_idle_network_detector)) { - connection_.GetTimeoutAlarm()->Fire(); - } EXPECT_TRUE(connection_.connected()); EXPECT_TRUE(connection_.GetTimeoutAlarm()->IsSet()); EXPECT_EQ(default_timeout + five_ms,