Internal change
PiperOrigin-RevId: 452326149
diff --git a/quiche/quic/core/congestion_control/bbr2_sender.cc b/quiche/quic/core/congestion_control/bbr2_sender.cc
index aa72f2a..6178907 100644
--- a/quiche/quic/core/congestion_control/bbr2_sender.cc
+++ b/quiche/quic/core/congestion_control/bbr2_sender.cc
@@ -505,11 +505,6 @@
}
}
-bool Bbr2Sender::ShouldSendProbingPacket() const {
- // TODO(wub): Implement ShouldSendProbingPacket properly.
- return BBR2_MODE_DISPATCH(IsProbingForBandwidth());
-}
-
std::string Bbr2Sender::GetDebugState() const {
std::ostringstream stream;
stream << ExportDebugState();
diff --git a/quiche/quic/core/congestion_control/bbr2_sender.h b/quiche/quic/core/congestion_control/bbr2_sender.h
index b9c0a41..7f47a4e 100644
--- a/quiche/quic/core/congestion_control/bbr2_sender.h
+++ b/quiche/quic/core/congestion_control/bbr2_sender.h
@@ -42,8 +42,6 @@
return false;
}
- bool ShouldSendProbingPacket() const override;
-
void SetFromConfig(const QuicConfig& config,
Perspective perspective) override;
diff --git a/quiche/quic/core/congestion_control/bbr_sender.cc b/quiche/quic/core/congestion_control/bbr_sender.cc
index aa121d4..878b598 100644
--- a/quiche/quic/core/congestion_control/bbr_sender.cc
+++ b/quiche/quic/core/congestion_control/bbr_sender.cc
@@ -204,16 +204,6 @@
return recovery_state_ != NOT_IN_RECOVERY;
}
-bool BbrSender::ShouldSendProbingPacket() const {
- if (pacing_gain_ <= 1) {
- return false;
- }
-
- // TODO(b/77975811): If the pipe is highly under-utilized, consider not
- // sending a probing transmission, because the extra bandwidth is not needed.
- return true;
-}
-
void BbrSender::SetFromConfig(const QuicConfig& config,
Perspective perspective) {
if (config.HasClientRequestedIndependentOption(k1RTT, perspective)) {
diff --git a/quiche/quic/core/congestion_control/bbr_sender.h b/quiche/quic/core/congestion_control/bbr_sender.h
index 9fe1199..5f711fd 100644
--- a/quiche/quic/core/congestion_control/bbr_sender.h
+++ b/quiche/quic/core/congestion_control/bbr_sender.h
@@ -100,7 +100,6 @@
// Start implementation of SendAlgorithmInterface.
bool InSlowStart() const override;
bool InRecovery() const override;
- bool ShouldSendProbingPacket() const override;
void SetFromConfig(const QuicConfig& config,
Perspective perspective) override;
diff --git a/quiche/quic/core/congestion_control/send_algorithm_interface.h b/quiche/quic/core/congestion_control/send_algorithm_interface.h
index 2979528..db14a1e 100644
--- a/quiche/quic/core/congestion_control/send_algorithm_interface.h
+++ b/quiche/quic/core/congestion_control/send_algorithm_interface.h
@@ -129,12 +129,6 @@
// Whether the send algorithm is currently in recovery.
virtual bool InRecovery() const = 0;
- // True when the congestion control is probing for more bandwidth and needs
- // enough data to not be app-limited to do so.
- // TODO(ianswett): In the future, this API may want to indicate the size of
- // the probing packet.
- virtual bool ShouldSendProbingPacket() const = 0;
-
// Returns the size of the slow start congestion window in bytes,
// aka ssthresh. Only defined for Cubic and Reno, other algorithms return 0.
virtual QuicByteCount GetSlowStartThreshold() const = 0;
diff --git a/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes.cc b/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes.cc
index 966a000..af0a5a9 100644
--- a/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes.cc
+++ b/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes.cc
@@ -233,8 +233,6 @@
largest_acked_packet_number_ <= largest_sent_at_last_cutback_;
}
-bool TcpCubicSenderBytes::ShouldSendProbingPacket() const { return false; }
-
void TcpCubicSenderBytes::OnRetransmissionTimeout(bool packets_retransmitted) {
largest_sent_at_last_cutback_.Clear();
if (!packets_retransmitted) {
diff --git a/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes.h b/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes.h
index a30f78d..2531e5a 100644
--- a/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes.h
+++ b/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes.h
@@ -69,7 +69,6 @@
CongestionControlType GetCongestionControlType() const override;
bool InSlowStart() const override;
bool InRecovery() const override;
- bool ShouldSendProbingPacket() const override;
std::string GetDebugState() const override;
void OnApplicationLimited(QuicByteCount bytes_in_flight) override;
void PopulateConnectionStats(QuicConnectionStats* /*stats*/) const override {}
diff --git a/quiche/quic/core/quic_connection.cc b/quiche/quic/core/quic_connection.cc
index a88d7f5..92db728 100644
--- a/quiche/quic/core/quic_connection.cc
+++ b/quiche/quic/core/quic_connection.cc
@@ -313,8 +313,6 @@
max_consecutive_num_packets_with_no_retransmittable_frames_(
kMaxConsecutiveNonRetransmittablePackets),
bundle_retransmittable_with_pto_ack_(false),
- fill_up_link_during_probing_(false),
- probing_retransmission_pending_(false),
last_control_frame_id_(kInvalidControlFrameId),
is_path_degrading_(false),
processing_ack_frame_(false),
@@ -3113,17 +3111,6 @@
}
}
-void QuicConnection::SendProbingRetransmissions() {
- while (sent_packet_manager_.GetSendAlgorithm()->ShouldSendProbingPacket() &&
- CanWrite(HAS_RETRANSMITTABLE_DATA)) {
- if (!visitor_->SendProbingData()) {
- QUIC_DVLOG(1)
- << "Cannot send probing retransmissions: nothing to retransmit.";
- break;
- }
- }
-}
-
void QuicConnection::MarkZeroRttPacketsForRetransmission(int reject_reason) {
sent_packet_manager_.MarkZeroRttPacketsForRetransmission();
if (debug_visitor_ != nullptr && version().UsesTls()) {
@@ -5451,29 +5438,8 @@
return false;
}
-void QuicConnection::MaybeSendProbingRetransmissions() {
- QUICHE_DCHECK(fill_up_link_during_probing_);
-
- // Don't send probing retransmissions until the handshake has completed.
- if (!IsHandshakeComplete() ||
- sent_packet_manager().HasUnackedCryptoPackets()) {
- return;
- }
-
- if (probing_retransmission_pending_) {
- QUIC_BUG(quic_bug_10511_37)
- << "MaybeSendProbingRetransmissions is called while another call "
- "to it is already in progress";
- return;
- }
-
- probing_retransmission_pending_ = true;
- SendProbingRetransmissions();
- probing_retransmission_pending_ = false;
-}
-
void QuicConnection::CheckIfApplicationLimited() {
- if (!connected_ || probing_retransmission_pending_) {
+ if (!connected_) {
return;
}
@@ -5484,13 +5450,6 @@
return;
}
- if (fill_up_link_during_probing_) {
- MaybeSendProbingRetransmissions();
- if (!CanWrite(HAS_RETRANSMITTABLE_DATA)) {
- return;
- }
- }
-
sent_packet_manager_.OnApplicationLimited();
}
diff --git a/quiche/quic/core/quic_connection.h b/quiche/quic/core/quic_connection.h
index 276a960..aab56b7 100644
--- a/quiche/quic/core/quic_connection.h
+++ b/quiche/quic/core/quic_connection.h
@@ -137,10 +137,6 @@
// Called when a blocked socket becomes writable.
virtual void OnCanWrite() = 0;
- // Called when the connection needs more data to probe for additional
- // bandwidth. Returns true if data was sent, false otherwise.
- virtual bool SendProbingData() = 0;
-
// Called when the connection experiences a change in congestion window.
virtual void OnCongestionWindowChange(QuicTime now) = 0;
@@ -1016,13 +1012,6 @@
return last_received_packet_info_.source_address;
}
- bool fill_up_link_during_probing() const {
- return fill_up_link_during_probing_;
- }
- void set_fill_up_link_during_probing(bool new_value) {
- fill_up_link_during_probing_ = new_value;
- }
-
// This setting may be changed during the crypto handshake in order to
// enable/disable padding of different packets in the crypto handshake.
//
@@ -1305,13 +1294,6 @@
// Returns true if the packet should be discarded and not sent.
virtual bool ShouldDiscardPacket(EncryptionLevel encryption_level);
- // Retransmits packets continuously until blocked by the congestion control.
- // If there are no packets to retransmit, does not do anything.
- void SendProbingRetransmissions();
-
- // Decides whether to send probing retransmissions, and does so if required.
- void MaybeSendProbingRetransmissions();
-
// Notify various components(Session etc.) that this connection has been
// migrated.
virtual void OnConnectionMigration();
@@ -2106,18 +2088,6 @@
// previously fired.
bool bundle_retransmittable_with_pto_ack_;
- // If true, the connection will fill up the pipe with extra data whenever the
- // congestion controller needs it in order to make a bandwidth estimate. This
- // is useful if the application pesistently underutilizes the link, but still
- // relies on having a reasonable bandwidth estimate from the connection, e.g.
- // for real time applications.
- bool fill_up_link_during_probing_;
-
- // If true, the probing retransmission will not be started again. This is
- // used to safeguard against an accidental tail recursion in probing
- // retransmission code.
- bool probing_retransmission_pending_;
-
// Id of latest sent control frame. 0 if no control frame has been sent.
QuicControlFrameId last_control_frame_id_;
diff --git a/quiche/quic/core/quic_connection_test.cc b/quiche/quic/core/quic_connection_test.cc
index 505c809..682f867 100644
--- a/quiche/quic/core/quic_connection_test.cc
+++ b/quiche/quic/core/quic_connection_test.cc
@@ -502,7 +502,6 @@
using QuicConnection::active_effective_peer_migration_type;
using QuicConnection::IsCurrentPacketConnectivityProbing;
using QuicConnection::SelectMutualVersion;
- using QuicConnection::SendProbingRetransmissions;
using QuicConnection::set_defer_send_in_response_to_packets;
protected:
@@ -7648,57 +7647,6 @@
connection_.OnCanWrite();
}
-// Test the mode in which the link is filled up with probing retransmissions if
-// the connection becomes application-limited.
-TEST_P(QuicConnectionTest, SendDataWhenApplicationLimited) {
- EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
- EXPECT_CALL(*send_algorithm_, ShouldSendProbingPacket())
- .WillRepeatedly(Return(true));
- {
- InSequence seq;
- EXPECT_CALL(visitor_, WillingAndAbleToWrite()).WillRepeatedly(Return(true));
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
- EXPECT_CALL(visitor_, WillingAndAbleToWrite())
- .WillRepeatedly(Return(false));
- }
- EXPECT_CALL(visitor_, SendProbingData()).WillRepeatedly([this] {
- return connection_.sent_packet_manager().MaybeRetransmitOldestPacket(
- PROBING_RETRANSMISSION);
- });
- // Fix congestion window to be 20,000 bytes.
- EXPECT_CALL(*send_algorithm_, CanSend(Ge(20000u)))
- .WillRepeatedly(Return(false));
- EXPECT_CALL(*send_algorithm_, CanSend(Lt(20000u)))
- .WillRepeatedly(Return(true));
-
- EXPECT_CALL(*send_algorithm_, OnApplicationLimited(_)).Times(0);
- ASSERT_EQ(0u, connection_.GetStats().packets_sent);
- connection_.set_fill_up_link_during_probing(true);
- EXPECT_CALL(visitor_, GetHandshakeState())
- .WillRepeatedly(Return(HANDSHAKE_CONFIRMED));
- connection_.OnHandshakeComplete();
- connection_.SendStreamData3();
-
- // We expect a lot of packets from a 20 kbyte window.
- EXPECT_GT(connection_.GetStats().packets_sent, 10u);
- // Ensure that the packets are padded.
- QuicByteCount average_packet_size =
- connection_.GetStats().bytes_sent / connection_.GetStats().packets_sent;
- EXPECT_GT(average_packet_size, 1000u);
-
- // Acknowledge all packets sent, except for the last one.
- QuicAckFrame ack = InitAckFrame(
- connection_.sent_packet_manager().GetLargestSentPacket() - 1);
- EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _, _));
- EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _));
-
- // Ensure that since we no longer have retransmittable bytes in flight, this
- // will not cause any responses to be sent.
- EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
- EXPECT_CALL(*send_algorithm_, OnApplicationLimited(_)).Times(1);
- ProcessAckPacket(&ack);
-}
-
TEST_P(QuicConnectionTest, DoNotForceSendingAckOnPacketTooLarge) {
EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
// Send an ack by simulating delayed ack alarm firing.
@@ -7839,83 +7787,6 @@
writer_->last_packet_header().destination_connection_id_included);
}
-TEST_P(QuicConnectionTest, SendProbingRetransmissions) {
- MockQuicConnectionDebugVisitor debug_visitor;
- connection_.set_debug_visitor(&debug_visitor);
-
- const QuicStreamId stream_id = 2;
- QuicPacketNumber last_packet;
- SendStreamDataToPeer(stream_id, "foo", 0, NO_FIN, &last_packet);
- SendStreamDataToPeer(stream_id, "bar", 3, NO_FIN, &last_packet);
- SendStreamDataToPeer(stream_id, "test", 6, NO_FIN, &last_packet);
-
- const QuicByteCount old_bytes_in_flight =
- connection_.sent_packet_manager().GetBytesInFlight();
-
- // Allow 9 probing retransmissions to be sent.
- {
- InSequence seq;
- EXPECT_CALL(*send_algorithm_, CanSend(_))
- .Times(9 * 2)
- .WillRepeatedly(Return(true));
- EXPECT_CALL(*send_algorithm_, CanSend(_)).WillOnce(Return(false));
- }
- // Expect them retransmitted in cyclic order (foo, bar, test, foo, bar...).
- QuicPacketCount sent_count = 0;
-
- EXPECT_CALL(debug_visitor, OnPacketSent(_, _, _, _, _, _, _, _))
- .WillRepeatedly(Invoke(
- [this, &sent_count](QuicPacketNumber, QuicPacketLength, bool,
- TransmissionType, EncryptionLevel,
- const QuicFrames&, const QuicFrames&, QuicTime) {
- ASSERT_EQ(1u, writer_->stream_frames().size());
- if (connection_.version().CanSendCoalescedPackets()) {
- // There is a delay of sending coalesced packet, so (6, 0, 3, 6,
- // 0...).
- EXPECT_EQ(3 * ((sent_count + 2) % 3),
- writer_->stream_frames()[0]->offset);
- } else {
- // Identify the frames by stream offset (0, 3, 6, 0, 3...).
- EXPECT_EQ(3 * (sent_count % 3),
- writer_->stream_frames()[0]->offset);
- }
- sent_count++;
- }));
-
- EXPECT_CALL(*send_algorithm_, ShouldSendProbingPacket())
- .WillRepeatedly(Return(true));
- EXPECT_CALL(visitor_, SendProbingData()).WillRepeatedly([this] {
- return connection_.sent_packet_manager().MaybeRetransmitOldestPacket(
- PROBING_RETRANSMISSION);
- });
-
- connection_.SendProbingRetransmissions();
-
- // Ensure that the in-flight has increased.
- const QuicByteCount new_bytes_in_flight =
- connection_.sent_packet_manager().GetBytesInFlight();
- EXPECT_GT(new_bytes_in_flight, old_bytes_in_flight);
-}
-
-// Ensure that SendProbingRetransmissions() does not retransmit anything when
-// there are no outstanding packets.
-TEST_P(QuicConnectionTest,
- SendProbingRetransmissionsFailsWhenNothingToRetransmit) {
- ASSERT_TRUE(connection_.sent_packet_manager().unacked_packets().empty());
-
- MockQuicConnectionDebugVisitor debug_visitor;
- connection_.set_debug_visitor(&debug_visitor);
- EXPECT_CALL(debug_visitor, OnPacketSent(_, _, _, _, _, _, _, _)).Times(0);
- EXPECT_CALL(*send_algorithm_, ShouldSendProbingPacket())
- .WillRepeatedly(Return(true));
- EXPECT_CALL(visitor_, SendProbingData()).WillRepeatedly([this] {
- return connection_.sent_packet_manager().MaybeRetransmitOldestPacket(
- PROBING_RETRANSMISSION);
- });
-
- connection_.SendProbingRetransmissions();
-}
-
TEST_P(QuicConnectionTest, PingAfterLastRetransmittablePacketAcked) {
const QuicTime::Delta retransmittable_on_wire_timeout =
QuicTime::Delta::FromMilliseconds(50);
diff --git a/quiche/quic/core/quic_control_frame_manager.cc b/quiche/quic/core/quic_control_frame_manager.cc
index d22ab04..1553cc8 100644
--- a/quiche/quic/core/quic_control_frame_manager.cc
+++ b/quiche/quic/core/quic_control_frame_manager.cc
@@ -274,7 +274,7 @@
bool QuicControlFrameManager::RetransmitControlFrame(const QuicFrame& frame,
TransmissionType type) {
- QUICHE_DCHECK(type == PTO_RETRANSMISSION || type == PROBING_RETRANSMISSION);
+ QUICHE_DCHECK(type == PTO_RETRANSMISSION);
QuicControlFrameId id = GetControlFrameId(frame);
if (id == kInvalidControlFrameId) {
// Frame does not have a valid control frame ID, ignore it. Returns true
diff --git a/quiche/quic/core/quic_packet_creator.cc b/quiche/quic/core/quic_packet_creator.cc
index 94921c4..e9938b3 100644
--- a/quiche/quic/core/quic_packet_creator.cc
+++ b/quiche/quic/core/quic_packet_creator.cc
@@ -1875,10 +1875,6 @@
return;
}
- if (packet_.transmission_type == PROBING_RETRANSMISSION) {
- needs_full_padding_ = true;
- }
-
if (packet_.fate == COALESCE || packet_.fate == LEGACY_VERSION_ENCAPSULATE) {
// Do not add full padding if the packet is going to be coalesced or
// encapsulated.
diff --git a/quiche/quic/core/quic_packet_creator_test.cc b/quiche/quic/core/quic_packet_creator_test.cc
index b0133fd..c9f8ecc 100644
--- a/quiche/quic/core/quic_packet_creator_test.cc
+++ b/quiche/quic/core/quic_packet_creator_test.cc
@@ -1939,7 +1939,7 @@
EXPECT_TRUE(creator_.AddFrame(stream_frame, PTO_RETRANSMISSION));
ASSERT_EQ(serialized_packet_, nullptr);
- EXPECT_TRUE(creator_.AddFrame(padding_frame, PROBING_RETRANSMISSION));
+ EXPECT_TRUE(creator_.AddFrame(padding_frame, LOSS_RETRANSMISSION));
creator_.FlushCurrentPacket();
ASSERT_TRUE(serialized_packet_->encrypted_buffer);
diff --git a/quiche/quic/core/quic_sent_packet_manager.cc b/quiche/quic/core/quic_sent_packet_manager.cc
index 76061c4..40da9f2 100644
--- a/quiche/quic/core/quic_sent_packet_manager.cc
+++ b/quiche/quic/core/quic_sent_packet_manager.cc
@@ -47,7 +47,6 @@
// the frames directly (as opposed to resulting in a loss notification).
inline bool ShouldForceRetransmission(TransmissionType transmission_type) {
return transmission_type == HANDSHAKE_RETRANSMISSION ||
- transmission_type == PROBING_RETRANSMISSION ||
transmission_type == PTO_RETRANSMISSION;
}
@@ -509,9 +508,6 @@
<< "packet number " << packet_number
<< " transmission_type: " << transmission_type << " transmission_info "
<< transmission_info->DebugString();
- // Handshake packets should never be sent as probing retransmissions.
- QUICHE_DCHECK(!transmission_info->has_crypto_handshake ||
- transmission_type != PROBING_RETRANSMISSION);
if (ShouldForceRetransmission(transmission_type)) {
if (!unacked_packets_.RetransmitFrames(
QuicFrames(transmission_info->retransmittable_frames),
diff --git a/quiche/quic/core/quic_sent_packet_manager_test.cc b/quiche/quic/core/quic_sent_packet_manager_test.cc
index 6c823a4..8c8076b 100644
--- a/quiche/quic/core/quic_sent_packet_manager_test.cc
+++ b/quiche/quic/core/quic_sent_packet_manager_test.cc
@@ -208,8 +208,7 @@
TransmissionType transmission_type) {
bool is_lost = false;
if (transmission_type == HANDSHAKE_RETRANSMISSION ||
- transmission_type == PTO_RETRANSMISSION ||
- transmission_type == PROBING_RETRANSMISSION) {
+ transmission_type == PTO_RETRANSMISSION) {
EXPECT_CALL(notifier_, RetransmitFrames(_, _))
.WillOnce(WithArgs<1>(
Invoke([this, new_packet_number](TransmissionType type) {
diff --git a/quiche/quic/core/quic_session.cc b/quiche/quic/core/quic_session.cc
index 8cd343d..d297600 100644
--- a/quiche/quic/core/quic_session.cc
+++ b/quiche/quic/core/quic_session.cc
@@ -692,14 +692,6 @@
}
}
-bool QuicSession::SendProbingData() {
- if (connection()->sent_packet_manager().MaybeRetransmitOldestPacket(
- PROBING_RETRANSMISSION)) {
- return true;
- }
- return false;
-}
-
bool QuicSession::WillingAndAbleToWrite() const {
// Schedule a write when:
// 1) control frame manager has pending or new control frames, or
diff --git a/quiche/quic/core/quic_session.h b/quiche/quic/core/quic_session.h
index 6cc9795..7bdcaa9 100644
--- a/quiche/quic/core/quic_session.h
+++ b/quiche/quic/core/quic_session.h
@@ -138,7 +138,6 @@
const QuicSocketAddress& peer_address,
bool is_connectivity_probe) override;
void OnCanWrite() override;
- bool SendProbingData() override;
void OnCongestionWindowChange(QuicTime /*now*/) override {}
void OnConnectionMigration(AddressChangeType /*type*/) override {}
// Adds a connection level WINDOW_UPDATE frame.
diff --git a/quiche/quic/core/quic_stream.cc b/quiche/quic/core/quic_stream.cc
index dcd07fb..dcbb02a 100644
--- a/quiche/quic/core/quic_stream.cc
+++ b/quiche/quic/core/quic_stream.cc
@@ -1136,7 +1136,7 @@
bool QuicStream::RetransmitStreamData(QuicStreamOffset offset,
QuicByteCount data_length, bool fin,
TransmissionType type) {
- QUICHE_DCHECK(type == PTO_RETRANSMISSION || type == PROBING_RETRANSMISSION);
+ QUICHE_DCHECK(type == PTO_RETRANSMISSION);
if (HasDeadlinePassed()) {
OnDeadlinePassed();
return true;
diff --git a/quiche/quic/core/quic_types.cc b/quiche/quic/core/quic_types.cc
index 3d52661..62760c9 100644
--- a/quiche/quic/core/quic_types.cc
+++ b/quiche/quic/core/quic_types.cc
@@ -215,7 +215,6 @@
RETURN_STRING_LITERAL(ALL_ZERO_RTT_RETRANSMISSION);
RETURN_STRING_LITERAL(LOSS_RETRANSMISSION);
RETURN_STRING_LITERAL(PTO_RETRANSMISSION);
- RETURN_STRING_LITERAL(PROBING_RETRANSMISSION);
RETURN_STRING_LITERAL(PATH_RETRANSMISSION);
RETURN_STRING_LITERAL(ALL_INITIAL_RETRANSMISSION);
default:
diff --git a/quiche/quic/core/quic_types.h b/quiche/quic/core/quic_types.h
index 8d5ca28..c79633c 100644
--- a/quiche/quic/core/quic_types.h
+++ b/quiche/quic/core/quic_types.h
@@ -181,7 +181,6 @@
// key.
LOSS_RETRANSMISSION, // Retransmits due to loss detection.
PTO_RETRANSMISSION, // Retransmission due to probe timeout.
- PROBING_RETRANSMISSION, // Retransmission in order to probe bandwidth.
PATH_RETRANSMISSION, // Retransmission proactively due to underlying
// network change.
ALL_INITIAL_RETRANSMISSION, // Retransmit all packets encrypted with INITIAL
@@ -545,8 +544,6 @@
LOST,
// This packet has been retransmitted when PTO fires.
PTO_RETRANSMITTED,
- // This packet has been retransmitted for probing purpose.
- PROBE_RETRANSMITTED,
// This packet is sent on a different path or is a PING only packet.
// Do not update RTT stats and congestion control if the packet is the
// largest_acked of an incoming ACK.
diff --git a/quiche/quic/core/quic_utils.cc b/quiche/quic/core/quic_utils.cc
index e1b1797..fdfce7e 100644
--- a/quiche/quic/core/quic_utils.cc
+++ b/quiche/quic/core/quic_utils.cc
@@ -171,7 +171,6 @@
RETURN_STRING_LITERAL(HANDSHAKE_RETRANSMITTED);
RETURN_STRING_LITERAL(LOST);
RETURN_STRING_LITERAL(PTO_RETRANSMITTED);
- RETURN_STRING_LITERAL(PROBE_RETRANSMITTED);
RETURN_STRING_LITERAL(NOT_CONTRIBUTING_RTT);
}
return "INVALID_SENT_PACKET_STATE";
@@ -289,8 +288,6 @@
return LOST;
case PTO_RETRANSMISSION:
return PTO_RETRANSMITTED;
- case PROBING_RETRANSMISSION:
- return PROBE_RETRANSMITTED;
case PATH_RETRANSMISSION:
return NOT_CONTRIBUTING_RTT;
case ALL_INITIAL_RETRANSMISSION:
diff --git a/quiche/quic/core/quic_utils_test.cc b/quiche/quic/core/quic_utils_test.cc
index a985b37..835cb97 100644
--- a/quiche/quic/core/quic_utils_test.cc
+++ b/quiche/quic/core/quic_utils_test.cc
@@ -131,8 +131,6 @@
EXPECT_EQ(UNACKABLE, state);
} else if (i == PTO_RETRANSMISSION) {
EXPECT_EQ(PTO_RETRANSMITTED, state);
- } else if (i == PROBING_RETRANSMISSION) {
- EXPECT_EQ(PROBE_RETRANSMITTED, state);
} else if (i == PATH_RETRANSMISSION) {
EXPECT_EQ(NOT_CONTRIBUTING_RTT, state);
} else if (i == ALL_INITIAL_RETRANSMISSION) {
diff --git a/quiche/quic/test_tools/quic_test_utils.h b/quiche/quic/test_tools/quic_test_utils.h
index 822e6c4..0e2c20c 100644
--- a/quiche/quic/test_tools/quic_test_utils.h
+++ b/quiche/quic/test_tools/quic_test_utils.h
@@ -453,7 +453,6 @@
(override));
MOCK_METHOD(void, OnWriteBlocked, (), (override));
MOCK_METHOD(void, OnCanWrite, (), (override));
- MOCK_METHOD(bool, SendProbingData, (), (override));
MOCK_METHOD(void, OnCongestionWindowChange, (QuicTime now), (override));
MOCK_METHOD(void, OnConnectionMigration, (AddressChangeType type),
(override));
@@ -1209,7 +1208,6 @@
MOCK_METHOD(std::string, GetDebugState, (), (const, override));
MOCK_METHOD(bool, InSlowStart, (), (const, override));
MOCK_METHOD(bool, InRecovery, (), (const, override));
- MOCK_METHOD(bool, ShouldSendProbingPacket, (), (const, override));
MOCK_METHOD(QuicByteCount, GetSlowStartThreshold, (), (const, override));
MOCK_METHOD(CongestionControlType, GetCongestionControlType, (),
(const, override));
diff --git a/quiche/quic/test_tools/simulator/quic_endpoint.cc b/quiche/quic/test_tools/simulator/quic_endpoint.cc
index 72f62ad..64005ec 100644
--- a/quiche/quic/test_tools/simulator/quic_endpoint.cc
+++ b/quiche/quic/test_tools/simulator/quic_endpoint.cc
@@ -151,14 +151,6 @@
WriteStreamData();
}
-bool QuicEndpoint::SendProbingData() {
- if (connection()->sent_packet_manager().MaybeRetransmitOldestPacket(
- PROBING_RETRANSMISSION)) {
- return true;
- }
- return false;
-}
-
bool QuicEndpoint::WillingAndAbleToWrite() const {
if (notifier_ != nullptr) {
return notifier_->WillingToWrite();
diff --git a/quiche/quic/test_tools/simulator/quic_endpoint.h b/quiche/quic/test_tools/simulator/quic_endpoint.h
index 71d4f1c..d3741c5 100644
--- a/quiche/quic/test_tools/simulator/quic_endpoint.h
+++ b/quiche/quic/test_tools/simulator/quic_endpoint.h
@@ -46,7 +46,6 @@
void OnStreamFrame(const QuicStreamFrame& frame) override;
void OnCryptoFrame(const QuicCryptoFrame& frame) override;
void OnCanWrite() override;
- bool SendProbingData() override;
bool WillingAndAbleToWrite() const override;
bool ShouldKeepConnectionAlive() const override;
