gfe-relnote: In QUIC, remove largest_sent_packets_ from unacked_packet_map. This only affects QUIC versions with TLS handshake. Protected by disabled gfe2_reloadable_flag_quic_enable_version_t* flags.
PiperOrigin-RevId: 291934571
Change-Id: Ifc0a73a9db508e9938dc14b40e76cc3fe00315c7
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index e987da9..03f5800 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -941,11 +941,11 @@
return true;
}
- if (!GetLargestSentPacket().IsInitialized() ||
- largest_acked > GetLargestSentPacket()) {
+ if (!sent_packet_manager_.GetLargestSentPacket().IsInitialized() ||
+ largest_acked > sent_packet_manager_.GetLargestSentPacket()) {
QUIC_DLOG(WARNING) << ENDPOINT
<< "Peer's observed unsent packet:" << largest_acked
- << " vs " << GetLargestSentPacket()
+ << " vs " << sent_packet_manager_.GetLargestSentPacket()
<< ". SupportsMultiplePacketNumberSpaces():"
<< SupportsMultiplePacketNumberSpaces()
<< ", last_decrypted_packet_level_:"
@@ -3965,14 +3965,6 @@
return largest_seen_packet_with_ack_;
}
-QuicPacketNumber QuicConnection::GetLargestSentPacket() const {
- if (SupportsMultiplePacketNumberSpaces()) {
- return sent_packet_manager_.GetLargestSentPacket(
- last_decrypted_packet_level_);
- }
- return sent_packet_manager_.GetLargestSentPacket();
-}
-
QuicPacketNumber QuicConnection::GetLargestAckedPacket() const {
if (SupportsMultiplePacketNumberSpaces()) {
return sent_packet_manager_.GetLargestAckedPacket(
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index ab99f05..080aa01 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -3586,7 +3586,13 @@
}
// Done processing the ACK frame.
- return visitor_->OnAckFrameEnd(QuicPacketNumber(first_received));
+ if (!visitor_->OnAckFrameEnd(QuicPacketNumber(first_received))) {
+ set_detailed_error(
+ "Error occurs when visitor finishes processing the ACK frame.");
+ return false;
+ }
+
+ return true;
}
bool QuicFramer::ProcessTimestampsInAckFrame(uint8_t num_received_packets,
@@ -3817,7 +3823,13 @@
ack_block_count--;
}
- return visitor_->OnAckFrameEnd(QuicPacketNumber(block_low));
+ if (!visitor_->OnAckFrameEnd(QuicPacketNumber(block_low))) {
+ set_detailed_error(
+ "Error occurs when visitor finishes processing the ACK frame.");
+ return false;
+ }
+
+ return true;
}
bool QuicFramer::ProcessStopWaitingFrame(QuicDataReader* reader,
diff --git a/quic/core/quic_sent_packet_manager.cc b/quic/core/quic_sent_packet_manager.cc
index 0137fde..767566c 100644
--- a/quic/core/quic_sent_packet_manager.cc
+++ b/quic/core/quic_sent_packet_manager.cc
@@ -1277,13 +1277,6 @@
QuicUtils::GetPacketNumberSpace(decrypted_packet_level));
}
-QuicPacketNumber QuicSentPacketManager::GetLargestSentPacket(
- EncryptionLevel decrypted_packet_level) const {
- DCHECK(supports_multiple_packet_number_spaces());
- return unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
- decrypted_packet_level);
-}
-
QuicPacketNumber QuicSentPacketManager::GetLargestPacketPeerKnowsIsAcked(
EncryptionLevel decrypted_packet_level) const {
DCHECK(supports_multiple_packet_number_spaces());
diff --git a/quic/core/quic_sent_packet_manager.h b/quic/core/quic_sent_packet_manager.h
index 686639a..ab53066 100644
--- a/quic/core/quic_sent_packet_manager.h
+++ b/quic/core/quic_sent_packet_manager.h
@@ -303,9 +303,6 @@
return unacked_packets_.largest_sent_packet();
}
- QuicPacketNumber GetLargestSentPacket(
- EncryptionLevel decrypted_packet_level) const;
-
QuicPacketNumber GetLargestPacketPeerKnowsIsAcked(
EncryptionLevel decrypted_packet_level) const;
diff --git a/quic/core/quic_sent_packet_manager_test.cc b/quic/core/quic_sent_packet_manager_test.cc
index f007562..49d0b1d 100644
--- a/quic/core/quic_sent_packet_manager_test.cc
+++ b/quic/core/quic_sent_packet_manager_test.cc
@@ -2457,16 +2457,23 @@
TEST_F(QuicSentPacketManagerTest, MultiplePacketNumberSpaces) {
manager_.EnableMultiplePacketNumberSpacesSupport();
+ const QuicUnackedPacketMap* unacked_packets =
+ QuicSentPacketManagerPeer::GetUnackedPacketMap(&manager_);
EXPECT_FALSE(
- manager_.GetLargestSentPacket(ENCRYPTION_INITIAL).IsInitialized());
+ unacked_packets
+ ->GetLargestSentRetransmittableOfPacketNumberSpace(INITIAL_DATA)
+ .IsInitialized());
EXPECT_FALSE(
manager_.GetLargestAckedPacket(ENCRYPTION_INITIAL).IsInitialized());
// Send packet 1.
SendDataPacket(1, ENCRYPTION_INITIAL);
EXPECT_EQ(QuicPacketNumber(1),
- manager_.GetLargestSentPacket(ENCRYPTION_INITIAL));
+ unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
+ INITIAL_DATA));
EXPECT_FALSE(
- manager_.GetLargestSentPacket(ENCRYPTION_HANDSHAKE).IsInitialized());
+ unacked_packets
+ ->GetLargestSentRetransmittableOfPacketNumberSpace(HANDSHAKE_DATA)
+ .IsInitialized());
// Ack packet 1.
ExpectAck(1);
manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
@@ -2483,11 +2490,15 @@
SendDataPacket(2, ENCRYPTION_HANDSHAKE);
SendDataPacket(3, ENCRYPTION_HANDSHAKE);
EXPECT_EQ(QuicPacketNumber(1),
- manager_.GetLargestSentPacket(ENCRYPTION_INITIAL));
+ unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
+ INITIAL_DATA));
EXPECT_EQ(QuicPacketNumber(3),
- manager_.GetLargestSentPacket(ENCRYPTION_HANDSHAKE));
+ unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
+ HANDSHAKE_DATA));
EXPECT_FALSE(
- manager_.GetLargestSentPacket(ENCRYPTION_ZERO_RTT).IsInitialized());
+ unacked_packets
+ ->GetLargestSentRetransmittableOfPacketNumberSpace(APPLICATION_DATA)
+ .IsInitialized());
// Ack packet 2.
ExpectAck(2);
manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
@@ -2516,13 +2527,14 @@
SendDataPacket(4, ENCRYPTION_ZERO_RTT);
SendDataPacket(5, ENCRYPTION_ZERO_RTT);
EXPECT_EQ(QuicPacketNumber(1),
- manager_.GetLargestSentPacket(ENCRYPTION_INITIAL));
+ unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
+ INITIAL_DATA));
EXPECT_EQ(QuicPacketNumber(3),
- manager_.GetLargestSentPacket(ENCRYPTION_HANDSHAKE));
+ unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
+ HANDSHAKE_DATA));
EXPECT_EQ(QuicPacketNumber(5),
- manager_.GetLargestSentPacket(ENCRYPTION_ZERO_RTT));
- EXPECT_EQ(QuicPacketNumber(5),
- manager_.GetLargestSentPacket(ENCRYPTION_FORWARD_SECURE));
+ unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
+ APPLICATION_DATA));
// Ack packet 5.
ExpectAck(5);
manager_.OnAckFrameStart(QuicPacketNumber(5), QuicTime::Delta::Infinite(),
@@ -2543,13 +2555,14 @@
SendDataPacket(7, ENCRYPTION_FORWARD_SECURE);
SendDataPacket(8, ENCRYPTION_FORWARD_SECURE);
EXPECT_EQ(QuicPacketNumber(1),
- manager_.GetLargestSentPacket(ENCRYPTION_INITIAL));
+ unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
+ INITIAL_DATA));
EXPECT_EQ(QuicPacketNumber(3),
- manager_.GetLargestSentPacket(ENCRYPTION_HANDSHAKE));
+ unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
+ HANDSHAKE_DATA));
EXPECT_EQ(QuicPacketNumber(8),
- manager_.GetLargestSentPacket(ENCRYPTION_ZERO_RTT));
- EXPECT_EQ(QuicPacketNumber(8),
- manager_.GetLargestSentPacket(ENCRYPTION_FORWARD_SECURE));
+ unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
+ APPLICATION_DATA));
// Ack all packets.
uint64_t acked[] = {4, 6, 7, 8};
ExpectAcksAndLosses(true, acked, QUICHE_ARRAYSIZE(acked), nullptr, 0);
diff --git a/quic/core/quic_unacked_packet_map.cc b/quic/core/quic_unacked_packet_map.cc
index 2db0f86..50f5c85 100644
--- a/quic/core/quic_unacked_packet_map.cc
+++ b/quic/core/quic_unacked_packet_map.cc
@@ -65,10 +65,6 @@
largest_sent_largest_acked_.UpdateMax(packet->largest_acked);
largest_sent_packet_ = packet_number;
- if (supports_multiple_packet_number_spaces_) {
- largest_sent_packets_[GetPacketNumberSpace(packet->encryption_level)] =
- packet_number;
- }
if (set_in_flight) {
bytes_in_flight_ += bytes_sent;
++packets_in_flight_;
@@ -456,10 +452,4 @@
supports_multiple_packet_number_spaces_ = true;
}
-QuicPacketNumber QuicUnackedPacketMap::GetLargestSentPacketOfPacketNumberSpace(
- EncryptionLevel encryption_level) const {
- DCHECK(supports_multiple_packet_number_spaces_);
- return largest_sent_packets_[GetPacketNumberSpace(encryption_level)];
-}
-
} // namespace quic
diff --git a/quic/core/quic_unacked_packet_map.h b/quic/core/quic_unacked_packet_map.h
index c106fd3..61261a5 100644
--- a/quic/core/quic_unacked_packet_map.h
+++ b/quic/core/quic_unacked_packet_map.h
@@ -245,8 +245,6 @@
const Perspective perspective_;
QuicPacketNumber largest_sent_packet_;
- // Only used when supports_multiple_packet_number_spaces_ is true.
- QuicPacketNumber largest_sent_packets_[NUM_PACKET_NUMBER_SPACES];
// The largest sent packet we expect to receive an ack for per packet number
// space.
QuicPacketNumber
diff --git a/quic/core/quic_unacked_packet_map_test.cc b/quic/core/quic_unacked_packet_map_test.cc
index 7439675..560b8cb 100644
--- a/quic/core/quic_unacked_packet_map_test.cc
+++ b/quic/core/quic_unacked_packet_map_test.cc
@@ -564,20 +564,21 @@
TEST_P(QuicUnackedPacketMapTest, LargestSentPacketMultiplePacketNumberSpaces) {
unacked_packets_.EnableMultiplePacketNumberSpacesSupport();
- EXPECT_FALSE(unacked_packets_
- .GetLargestSentPacketOfPacketNumberSpace(ENCRYPTION_INITIAL)
- .IsInitialized());
+ EXPECT_FALSE(
+ unacked_packets_
+ .GetLargestSentRetransmittableOfPacketNumberSpace(INITIAL_DATA)
+ .IsInitialized());
// Send packet 1.
SerializedPacket packet1(CreateRetransmittablePacket(1));
packet1.encryption_level = ENCRYPTION_INITIAL;
unacked_packets_.AddSentPacket(&packet1, NOT_RETRANSMISSION, now_, true);
EXPECT_EQ(QuicPacketNumber(1u), unacked_packets_.largest_sent_packet());
EXPECT_EQ(QuicPacketNumber(1),
- unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
- ENCRYPTION_INITIAL));
+ unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
+ INITIAL_DATA));
EXPECT_FALSE(
unacked_packets_
- .GetLargestSentPacketOfPacketNumberSpace(ENCRYPTION_HANDSHAKE)
+ .GetLargestSentRetransmittableOfPacketNumberSpace(HANDSHAKE_DATA)
.IsInitialized());
// Send packet 2.
SerializedPacket packet2(CreateRetransmittablePacket(2));
@@ -585,33 +586,34 @@
unacked_packets_.AddSentPacket(&packet2, NOT_RETRANSMISSION, now_, true);
EXPECT_EQ(QuicPacketNumber(2u), unacked_packets_.largest_sent_packet());
EXPECT_EQ(QuicPacketNumber(1),
- unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
- ENCRYPTION_INITIAL));
+ unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
+ INITIAL_DATA));
EXPECT_EQ(QuicPacketNumber(2),
- unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
- ENCRYPTION_HANDSHAKE));
- EXPECT_FALSE(unacked_packets_
- .GetLargestSentPacketOfPacketNumberSpace(ENCRYPTION_ZERO_RTT)
- .IsInitialized());
+ unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
+ HANDSHAKE_DATA));
+ EXPECT_FALSE(
+ unacked_packets_
+ .GetLargestSentRetransmittableOfPacketNumberSpace(APPLICATION_DATA)
+ .IsInitialized());
// Send packet 3.
SerializedPacket packet3(CreateRetransmittablePacket(3));
packet3.encryption_level = ENCRYPTION_ZERO_RTT;
unacked_packets_.AddSentPacket(&packet3, NOT_RETRANSMISSION, now_, true);
EXPECT_EQ(QuicPacketNumber(3u), unacked_packets_.largest_sent_packet());
EXPECT_EQ(QuicPacketNumber(1),
- unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
- ENCRYPTION_INITIAL));
+ unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
+ INITIAL_DATA));
EXPECT_EQ(QuicPacketNumber(2),
- unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
- ENCRYPTION_HANDSHAKE));
+ unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
+ HANDSHAKE_DATA));
EXPECT_EQ(QuicPacketNumber(3),
- unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
- ENCRYPTION_ZERO_RTT));
+ unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
+ APPLICATION_DATA));
// Verify forward secure belongs to the same packet number space as encryption
// zero rtt.
EXPECT_EQ(QuicPacketNumber(3),
- unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
- ENCRYPTION_FORWARD_SECURE));
+ unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
+ APPLICATION_DATA));
// Send packet 4.
SerializedPacket packet4(CreateRetransmittablePacket(4));
@@ -619,19 +621,19 @@
unacked_packets_.AddSentPacket(&packet4, NOT_RETRANSMISSION, now_, true);
EXPECT_EQ(QuicPacketNumber(4u), unacked_packets_.largest_sent_packet());
EXPECT_EQ(QuicPacketNumber(1),
- unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
- ENCRYPTION_INITIAL));
+ unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
+ INITIAL_DATA));
EXPECT_EQ(QuicPacketNumber(2),
- unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
- ENCRYPTION_HANDSHAKE));
+ unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
+ HANDSHAKE_DATA));
EXPECT_EQ(QuicPacketNumber(4),
- unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
- ENCRYPTION_ZERO_RTT));
+ unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
+ APPLICATION_DATA));
// Verify forward secure belongs to the same packet number space as encryption
// zero rtt.
EXPECT_EQ(QuicPacketNumber(4),
- unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
- ENCRYPTION_FORWARD_SECURE));
+ unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
+ APPLICATION_DATA));
}
} // namespace
