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

net/quic/core/quic_framer.cc

Index: net/quic/core/quic_framer.cc
diff --git a/net/quic/core/quic_framer.cc b/net/quic/core/quic_framer.cc
index 87ef7af79d09dd1aa256e41c585bd31bbf7f9959..bf16bf1e7d3267e41705a814386fea615eac6233 100644
--- a/net/quic/core/quic_framer.cc
+++ b/net/quic/core/quic_framer.cc
@@ -23,6 +23,7 @@
 #include "net/quic/core/quic_socket_address_coder.h"
 #include "net/quic/core/quic_utils.h"
 
+using base::ContainsKey;
 using base::StringPiece;
 using std::map;
 using std::max;
@@ -142,6 +143,7 @@ QuicFramer::QuicFramer(const QuicVersionVector& supported_versions,
       entropy_calculator_(nullptr),
       error_(QUIC_NO_ERROR),
       last_packet_number_(0),
+      largest_packet_number_(0),
       last_path_id_(kInvalidPathId),
       last_serialized_connection_id_(0),
       supported_versions_(supported_versions),
@@ -799,21 +801,34 @@ const QuicTime::Delta QuicFramer::CalculateTimestampFromWire(
 }
 
 bool QuicFramer::IsValidPath(QuicPathId path_id,
-                             QuicPacketNumber* last_packet_number) {
-  if (base::ContainsKey(closed_paths_, path_id)) {
+                             QuicPacketNumber* base_packet_number) {
+  if (ContainsKey(closed_paths_, path_id)) {
     // Path is closed.
     return false;
   }
 
-  if (path_id == last_path_id_) {
-    *last_packet_number = last_packet_number_;
-    return true;
-  }
+  if (FLAGS_quic_packet_numbers_largest_received) {
+    if (path_id == last_path_id_) {
+      *base_packet_number = largest_packet_number_;
+      return true;
+    }
 
-  if (base::ContainsKey(last_packet_numbers_, path_id)) {
-    *last_packet_number = last_packet_numbers_[path_id];
+    if (ContainsKey(largest_packet_numbers_, path_id)) {
+      *base_packet_number = largest_packet_numbers_[path_id];
+    } else {
+      *base_packet_number = 0;
+    }
   } else {
-    *last_packet_number = 0;
+    if (path_id == last_path_id_) {
+      *base_packet_number = last_packet_number_;
+      return true;
+    }
+
+    if (ContainsKey(last_packet_numbers_, path_id)) {
+      *base_packet_number = last_packet_numbers_[path_id];
+    } else {
+      *base_packet_number = 0;
+    }
   }
 
   return true;
@@ -824,11 +839,17 @@ void QuicFramer::SetLastPacketNumber(const QuicPacketHeader& header) {
     if (last_path_id_ != kInvalidPathId) {
       // Save current last packet number before changing path.
       last_packet_numbers_[last_path_id_] = last_packet_number_;
+      if (FLAGS_quic_packet_numbers_largest_received) {
+        largest_packet_numbers_[last_path_id_] = largest_packet_number_;
+      }
     }
     // Change path.
     last_path_id_ = header.path_id;
   }
   last_packet_number_ = header.packet_number;
+  if (FLAGS_quic_packet_numbers_largest_received) {
+    largest_packet_number_ = max(header.packet_number, largest_packet_number_);
+  }
 }
 
 void QuicFramer::OnPathClosed(QuicPathId path_id) {
@@ -838,7 +859,7 @@ void QuicFramer::OnPathClosed(QuicPathId path_id) {
 
 QuicPacketNumber QuicFramer::CalculatePacketNumberFromWire(
     QuicPacketNumberLength packet_number_length,
-    QuicPacketNumber last_packet_number,
+    QuicPacketNumber base_packet_number,
     QuicPacketNumber packet_number) const {
   // The new packet number might have wrapped to the next epoch, or
   // it might have reverse wrapped to the previous epoch, or it might
@@ -850,8 +871,8 @@ QuicPacketNumber QuicFramer::CalculatePacketNumberFromWire(
   // number or an adjacent epoch.
   const QuicPacketNumber epoch_delta = UINT64_C(1)
                                        << (8 * packet_number_length);
-  QuicPacketNumber next_packet_number = last_packet_number + 1;
-  QuicPacketNumber epoch = last_packet_number & ~(epoch_delta - 1);
+  QuicPacketNumber next_packet_number = base_packet_number + 1;
+  QuicPacketNumber epoch = base_packet_number & ~(epoch_delta - 1);
   QuicPacketNumber prev_epoch = epoch - epoch_delta;
   QuicPacketNumber next_epoch = epoch + epoch_delta;
 
@@ -1051,16 +1072,19 @@ bool QuicFramer::ProcessUnauthenticatedHeader(QuicDataReader* encrypted_reader,
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
-  QuicPacketNumber last_packet_number = last_packet_number_;
+  QuicPacketNumber base_packet_number =
+      FLAGS_quic_packet_numbers_largest_received
+          ? largest_packet_number_
+          : last_packet_number_;
   if (header->public_header.multipath_flag &&
-      !IsValidPath(header->path_id, &last_packet_number)) {
+      !IsValidPath(header->path_id, &base_packet_number)) {
     // Stop processing because path is closed.
     return false;
   }
 
   if (!ProcessPacketSequenceNumber(
           encrypted_reader, header->public_header.packet_number_length,
-          last_packet_number, &header->packet_number)) {
+          base_packet_number, &header->packet_number)) {
     set_detailed_error("Unable to read packet number.");
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
@@ -1128,7 +1152,7 @@ bool QuicFramer::ProcessPathId(QuicDataReader* reader, QuicPathId* path_id) {
 bool QuicFramer::ProcessPacketSequenceNumber(
     QuicDataReader* reader,
     QuicPacketNumberLength packet_number_length,
-    QuicPacketNumber last_packet_number,
+    QuicPacketNumber base_packet_number,
     QuicPacketNumber* packet_number) {
   QuicPacketNumber wire_packet_number = 0u;
   if (!reader->ReadBytes(&wire_packet_number, packet_number_length)) {
@@ -1138,7 +1162,7 @@ bool QuicFramer::ProcessPacketSequenceNumber(
   // TODO(ianswett): Explore the usefulness of trying multiple packet numbers
   // in case the first guess is incorrect.
   *packet_number = CalculatePacketNumberFromWire(
-      packet_number_length, last_packet_number, wire_packet_number);
+      packet_number_length, base_packet_number, wire_packet_number);
   return true;
 }