gfe-relnote: In QUIC, add setter and getter for largest_seen_packet_with_ack_. Also add GetLargestSentPacket and GetLargestAckedPacket. No functional change expected. Not protected.

These setter/getters would be different when multiple packet number spaces are supported.

PiperOrigin-RevId: 239271625
Change-Id: Iddbb1fc2ae2a194f4f273651af5962d63d6f929a

quic/core/quic_connection.cc

diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 3ead1d2..17752a6 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -960,33 +960,33 @@
   QUIC_DVLOG(1) << ENDPOINT
                 << "OnAckFrameStart, largest_acked: " << largest_acked;
 
-  if (largest_seen_packet_with_ack_.IsInitialized() &&
-      last_header_.packet_number <= largest_seen_packet_with_ack_) {
+  if (GetLargestReceivedPacketWithAck().IsInitialized() &&
+      last_header_.packet_number <= GetLargestReceivedPacketWithAck()) {
     QUIC_DLOG(INFO) << ENDPOINT << "Received an old ack frame: ignoring";
     return true;
   }
 
-  if (!sent_packet_manager_.GetLargestSentPacket().IsInitialized() ||
-      largest_acked > sent_packet_manager_.GetLargestSentPacket()) {
+  if (!GetLargestSentPacket().IsInitialized() ||
+      largest_acked > GetLargestSentPacket()) {
     QUIC_DLOG(WARNING) << ENDPOINT
                        << "Peer's observed unsent packet:" << largest_acked
-                       << " vs " << sent_packet_manager_.GetLargestSentPacket();
+                       << " vs " << GetLargestSentPacket();
     // We got an ack for data we have not sent.
     CloseConnection(QUIC_INVALID_ACK_DATA, "Largest observed too high.",
                     ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     return false;
   }
 
-  if (!sent_packet_manager_.GetLargestObserved().IsInitialized() ||
-      largest_acked > sent_packet_manager_.GetLargestObserved()) {
+  if (!GetLargestAckedPacket().IsInitialized() ||
+      largest_acked > GetLargestAckedPacket()) {
     visitor_->OnForwardProgressConfirmed();
   } else if (!sent_packet_manager_.tolerate_reneging() &&
-             largest_acked < sent_packet_manager_.GetLargestObserved()) {
+             largest_acked < GetLargestAckedPacket()) {
     QUIC_LOG(INFO) << ENDPOINT << "Peer's largest_observed packet decreased:"
-                   << largest_acked << " vs "
-                   << sent_packet_manager_.GetLargestObserved()
+                   << largest_acked << " vs " << GetLargestAckedPacket()
                    << " packet_number:" << last_header_.packet_number
-                   << " largest seen with ack:" << largest_seen_packet_with_ack_
+                   << " largest seen with ack:"
+                   << GetLargestReceivedPacketWithAck()
                    << " connection_id: " << connection_id_;
     // A new ack has a diminished largest_observed value.
     // If this was an old packet, we wouldn't even have checked.
@@ -1004,8 +1004,8 @@
   DCHECK(connected_);
   QUIC_DVLOG(1) << ENDPOINT << "OnAckRange: [" << start << ", " << end << ")";
 
-  if (largest_seen_packet_with_ack_.IsInitialized() &&
-      last_header_.packet_number <= largest_seen_packet_with_ack_) {
+  if (GetLargestReceivedPacketWithAck().IsInitialized() &&
+      last_header_.packet_number <= GetLargestReceivedPacketWithAck()) {
     QUIC_DLOG(INFO) << ENDPOINT << "Received an old ack frame: ignoring";
     return true;
   }
@@ -1020,8 +1020,8 @@
   QUIC_DVLOG(1) << ENDPOINT << "OnAckTimestamp: [" << packet_number << ", "
                 << timestamp.ToDebuggingValue() << ")";
 
-  if (largest_seen_packet_with_ack_.IsInitialized() &&
-      last_header_.packet_number <= largest_seen_packet_with_ack_) {
+  if (GetLargestReceivedPacketWithAck().IsInitialized() &&
+      last_header_.packet_number <= GetLargestReceivedPacketWithAck()) {
     QUIC_DLOG(INFO) << ENDPOINT << "Received an old ack frame: ignoring";
     return true;
   }
@@ -1034,8 +1034,8 @@
   DCHECK(connected_);
   QUIC_DVLOG(1) << ENDPOINT << "OnAckFrameEnd, start: " << start;
 
-  if (largest_seen_packet_with_ack_.IsInitialized() &&
-      last_header_.packet_number <= largest_seen_packet_with_ack_) {
+  if (GetLargestReceivedPacketWithAck().IsInitialized() &&
+      last_header_.packet_number <= GetLargestReceivedPacketWithAck()) {
     QUIC_DLOG(INFO) << ENDPOINT << "Received an old ack frame: ignoring";
     return true;
   }
@@ -1051,7 +1051,7 @@
     // Update pace time into future because smoothed RTT is likely updated.
     UpdateReleaseTimeIntoFuture();
   }
-  largest_seen_packet_with_ack_ = last_header_.packet_number;
+  SetLargestReceivedPacketWithAck(last_header_.packet_number);
   // If the incoming ack's packets set expresses missing packets: peer is still
   // waiting for a packet lower than a packet that we are no longer planning to
   // send.
@@ -3758,6 +3758,23 @@
   return ENCRYPTION_INITIAL;
 }
 
+void QuicConnection::SetLargestReceivedPacketWithAck(
+    QuicPacketNumber new_value) {
+  largest_seen_packet_with_ack_ = new_value;
+}
+
+QuicPacketNumber QuicConnection::GetLargestReceivedPacketWithAck() const {
+  return largest_seen_packet_with_ack_;
+}
+
+QuicPacketNumber QuicConnection::GetLargestSentPacket() const {
+  return sent_packet_manager_.GetLargestSentPacket();
+}
+
+QuicPacketNumber QuicConnection::GetLargestAckedPacket() const {
+  return sent_packet_manager_.GetLargestObserved();
+}
+
 size_t QuicConnection::min_received_before_ack_decimation() const {
   if (received_packet_manager_.decide_when_to_send_acks()) {
     return received_packet_manager_.min_received_before_ack_decimation();

quic/core/quic_connection.h

diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index b40e5c6..a2202ee 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -1098,6 +1098,19 @@
   // which is the highest encryption level that peer can guarantee to process.
   EncryptionLevel GetConnectionCloseEncryptionLevel() const;
 
+  // Called after an ACK frame is successfully processed to update largest
+  // received packet number which contains an ACK frame.
+  void SetLargestReceivedPacketWithAck(QuicPacketNumber new_value);
+
+  // Returns largest received packet number which contains an ACK frame.
+  QuicPacketNumber GetLargestReceivedPacketWithAck() const;
+
+  // Returns the largest packet number that has been sent.
+  QuicPacketNumber GetLargestSentPacket() const;
+
+  // Returns the largest sent packet number that has been ACKed by peer.
+  QuicPacketNumber GetLargestAckedPacket() const;
+
   QuicFramer framer_;
 
   // Contents received in the current packet, especially used to identify
@@ -1163,6 +1176,8 @@
 
   // Track some peer state so we can do less bookkeeping
   // Largest sequence sent by the peer which had an ack frame (latest ack info).
+  // Do not read or write directly, use GetLargestReceivedPacketWithAck() and
+  // SetLargestReceivedPacketWithAck() instead.
   QuicPacketNumber largest_seen_packet_with_ack_;
 
   // Largest packet number sent by the peer which had a stop waiting frame.