Largest received -> largest observed.

net/quic/quic_protocol.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef NET_QUIC_QUIC_PROTOCOL_H_
 #define NET_QUIC_QUIC_PROTOCOL_H_
 
 #include <stddef.h>
 #include <limits>
 #include <map>
@@ skipping 180 matching lines @@
 
 struct NET_EXPORT_PRIVATE ReceivedPacketInfo {
   ReceivedPacketInfo();
   ~ReceivedPacketInfo();
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os, const ReceivedPacketInfo& s);
 
   // Records a packet receipt.
   void RecordReceived(QuicPacketSequenceNumber sequence_number);
 
-  // True if the sequence number is greater than largest_received or is listed
+  // True if the sequence number is greater than largest_observed or is listed
   // as missing.
   // Always returns false for sequence numbers less than least_unacked.
   bool IsAwaitingPacket(QuicPacketSequenceNumber sequence_number) const;
 
   // Clears all missing packets less than |least_unacked|.
   void ClearMissingBefore(QuicPacketSequenceNumber least_unacked);
 
-  // The highest packet sequence number we've received from the peer.
-  QuicPacketSequenceNumber largest_received;
+  // The highest packet sequence number we've observed from the peer.
+  //
+  // In general, this should be the largest packet number we've received.  In
+  // the case of truncated acks, we may have to advertise a lower "upper bound"
+  // than largest received, to avoid implicitly acking missing packets that
+  // don't fit in the missing packet list due to size limitations.  In this
+  // case, largest_observed may be a packet which is also in the missing packets
+  // list.
+  QuicPacketSequenceNumber largest_observed;
 
   // The set of packets which we're expecting and have not received.
   SequenceSet missing_packets;
 };
 
 struct NET_EXPORT_PRIVATE SentPacketInfo {
   SentPacketInfo();
   ~SentPacketInfo();
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os, const SentPacketInfo& s);
 
   // The lowest packet we've sent which is unacked, and we expect an ack for.
   QuicPacketSequenceNumber least_unacked;
 };
 
 struct NET_EXPORT_PRIVATE QuicAckFrame {
   QuicAckFrame() {}
   // Testing convenience method to construct a QuicAckFrame with all packets
-  // from least_unacked to largest_received acked.
-  QuicAckFrame(QuicPacketSequenceNumber largest_received,
+  // from least_unacked to largest_observed acked.
+  QuicAckFrame(QuicPacketSequenceNumber largest_observed,
                QuicPacketSequenceNumber least_unacked);
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os, const QuicAckFrame& s);
 
   SentPacketInfo sent_info;
   ReceivedPacketInfo received_info;
 };
 
 // Defines for all types of congestion feedback that will be negotiated in QUIC,
@@ skipping 185 matching lines @@
     return base::StringPiece(data() + kStartOfHashData, kStartOfEncryptedData);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QuicEncryptedPacket);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PROTOCOL_H_