Use the largest received packet instead of the most recently received packet to calculate the seque…

net/quic/core/quic_framer.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_FRAMER_H_
 #define NET_QUIC_QUIC_FRAMER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 423 matching lines @@
                                     QuicPacketHeader* header);
 
   // Processes the authenticated portion of the header into |header| from
   // the current QuicDataReader.  Returns true on success, false on failure.
   bool ProcessAuthenticatedHeader(QuicDataReader* reader,
                                   QuicPacketHeader* header);
 
   bool ProcessPathId(QuicDataReader* reader, QuicPathId* path_id);
   bool ProcessPacketSequenceNumber(QuicDataReader* reader,
                                    QuicPacketNumberLength packet_number_length,
-                                   QuicPacketNumber last_packet_number,
+                                   QuicPacketNumber base_packet_number,
                                    QuicPacketNumber* packet_number);
   bool ProcessFrameData(QuicDataReader* reader, const QuicPacketHeader& header);
   bool ProcessStreamFrame(QuicDataReader* reader,
                           uint8_t frame_type,
                           QuicStreamFrame* frame);
   bool ProcessAckFrame(QuicDataReader* reader,
                        uint8_t frame_type,
                        QuicAckFrame* frame);
   bool ProcessNewAckFrame(QuicDataReader* reader,
                           uint8_t frame_type,
@@ skipping 12 matching lines @@
   bool ProcessPathCloseFrame(QuicDataReader* reader, QuicPathCloseFrame* frame);
 
   bool DecryptPayload(QuicDataReader* encrypted_reader,
                       const QuicPacketHeader& header,
                       const QuicEncryptedPacket& packet,
                       char* decrypted_buffer,
                       size_t buffer_length,
                       size_t* decrypted_length);
 
   // Checks if |path_id| is a viable path to receive packets on. Returns true
-  // and sets |last_packet_number| if the path is not closed. Returns false
+  // and sets |base_packet_number| to the packet number to calculate the
+  // incoming packet number from if the path is not closed. Returns false
   // otherwise.
-  bool IsValidPath(QuicPathId path_id, QuicPacketNumber* last_packet_number);
+  bool IsValidPath(QuicPathId path_id, QuicPacketNumber* base_packet_number);
 
   // Sets last_packet_number_. This can only be called after the packet is
   // successfully decrypted.
   void SetLastPacketNumber(const QuicPacketHeader& header);
 
   // Returns the full packet number from the truncated
   // wire format version and the last seen packet number.
   QuicPacketNumber CalculatePacketNumberFromWire(
       QuicPacketNumberLength packet_number_length,
-      QuicPacketNumber last_packet_number,
+      QuicPacketNumber base_packet_number,
       QuicPacketNumber packet_number) const;
 
   // Returns the QuicTime::Delta corresponding to the time from when the framer
   // was created.
   const QuicTime::Delta CalculateTimestampFromWire(uint32_t time_delta_us);
 
   // Computes the wire size in bytes of time stamps in |ack|.
   size_t GetAckFrameTimeStampSize(const QuicAckFrame& ack);
 
   // Computes the wire size in bytes of the |ack| frame, assuming no truncation.
@@ skipping 62 matching lines @@
   QuicFramerVisitorInterface* visitor_;
   QuicReceivedEntropyHashCalculatorInterface* entropy_calculator_;
   QuicErrorCode error_;
   // Set of closed paths. A path is considered as closed if a PATH_CLOSED frame
   // has been sent/received.
   // TODO(fayang): this set is never cleaned up. A possible improvement is to
   // use intervals.
   std::unordered_set<QuicPathId> closed_paths_;
   // Map mapping path id to packet number of last successfully decrypted
   // received packet.
+  // TODO(ianswett): Remove when
+  // gfe2_reloadable_flag_quic_packet_numbers_largest_received is deprecated.
   std::unordered_map<QuicPathId, QuicPacketNumber> last_packet_numbers_;
   // Updated by ProcessPacketHeader when it succeeds.
   QuicPacketNumber last_packet_number_;
+  // Map mapping path id to packet number of largest successfully decrypted
+  // received packet.
+  std::unordered_map<QuicPathId, QuicPacketNumber> largest_packet_numbers_;
+  // Updated by ProcessPacketHeader when it succeeds decrypting a larger packet.
+  QuicPacketNumber largest_packet_number_;
   // The path on which last successfully decrypted packet was received.
   QuicPathId last_path_id_;
   // Updated by WritePacketHeader.
   QuicConnectionId last_serialized_connection_id_;
   // The last QUIC version tag received.
   QuicTag last_version_tag_;
   // Version of the protocol being used.
   QuicVersion quic_version_;
   // This vector contains QUIC versions which we currently support.
   // This should be ordered such that the highest supported version is the first
@@ skipping 27 matching lines @@
   QuicTime::Delta last_timestamp_;
   // The diversification nonce from the last received packet.
   DiversificationNonce last_nonce_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicFramer);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_FRAMER_H_