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

net/quic/core/quic_framer_test.cc

 // 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.
 
 #include "net/quic/core/quic_framer.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 1178 matching lines @@
       framer_.version() <= QUIC_VERSION_33 ? arraysize(packet)
                                            : arraysize(packet_34),
       false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   EXPECT_EQ(0u, QuicFramerPeer::GetLastPacketNumber(&framer_));
   EXPECT_EQ(kInvalidPathId, QuicFramerPeer::GetLastPathId(&framer_));
 }
 
 TEST_P(QuicFramerTest, PacketHeaderWith4BytePacketNumber) {
-  QuicFramerPeer::SetLastPacketNumber(&framer_, kPacketNumber - 2);
+  if (FLAGS_quic_packet_numbers_largest_received) {
+    QuicFramerPeer::SetLargestPacketNumber(&framer_, kPacketNumber - 2);
+  } else {
+    QuicFramerPeer::SetLastPacketNumber(&framer_, kPacketNumber - 2);
+  }
 
   // clang-format off
   unsigned char packet[] = {
     // public flags (8 byte connection_id and 4 byte packet number)
     0x28,
     // connection_id
     0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
     // packet number
     0xBC, 0x9A, 0x78, 0x56,
     // private flags
@@ skipping 50 matching lines @@
         expected_error = "Unable to read packet number.";
       }
     }
     CheckProcessingFails(
         framer_.version() <= QUIC_VERSION_33 ? packet : packet_34, i,
         expected_error, QUIC_INVALID_PACKET_HEADER);
   }
 }
 
 TEST_P(QuicFramerTest, PacketHeaderWith2BytePacketNumber) {
-  QuicFramerPeer::SetLastPacketNumber(&framer_, kPacketNumber - 2);
+  if (FLAGS_quic_packet_numbers_largest_received) {
+    QuicFramerPeer::SetLargestPacketNumber(&framer_, kPacketNumber - 2);
+  } else {
+    QuicFramerPeer::SetLastPacketNumber(&framer_, kPacketNumber - 2);
+  }
 
   // clang-format off
   unsigned char packet[] = {
     // public flags (8 byte connection_id and 2 byte packet number)
     0x18,
     // connection_id
     0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
     // packet number
     0xBC, 0x9A,
     // private flags
@@ skipping 14 matching lines @@
       framer_.version() <= QUIC_VERSION_33 ? arraysize(packet)
                                            : arraysize(packet_34),
       false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_FALSE(visitor_.header_->public_header.multipath_flag);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
+  EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER,
+            visitor_.header_->public_header.packet_number_length);
   EXPECT_FALSE(visitor_.header_->fec_flag);
   EXPECT_FALSE(visitor_.header_->entropy_flag);
   EXPECT_EQ(0, visitor_.header_->entropy_hash);
   EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
 
   // Now test framing boundaries.
   for (size_t i = 0;
        i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                !kIncludeVersion, !kIncludePathId,
                                !kIncludeDiversificationNonce,
@@ skipping 16 matching lines @@
         expected_error = "Unable to read packet number.";
       }
     }
     CheckProcessingFails(
         framer_.version() <= QUIC_VERSION_33 ? packet : packet_34, i,
         expected_error, QUIC_INVALID_PACKET_HEADER);
   }
 }
 
 TEST_P(QuicFramerTest, PacketHeaderWith1BytePacketNumber) {
-  QuicFramerPeer::SetLastPacketNumber(&framer_, kPacketNumber - 2);
+  if (FLAGS_quic_packet_numbers_largest_received) {
+    QuicFramerPeer::SetLargestPacketNumber(&framer_, kPacketNumber - 2);
+  } else {
+    QuicFramerPeer::SetLastPacketNumber(&framer_, kPacketNumber - 2);
+  }
 
   // clang-format off
   unsigned char packet[] = {
     // public flags (8 byte connection_id and 1 byte packet number)
     0x08,
     // connection_id
     0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
     // packet number
     0xBC,
     // private flags
@@ skipping 14 matching lines @@
       framer_.version() <= QUIC_VERSION_33 ? arraysize(packet)
                                            : arraysize(packet_34),
       false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_FALSE(visitor_.header_->public_header.multipath_flag);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
+  EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
+            visitor_.header_->public_header.packet_number_length);
   EXPECT_FALSE(visitor_.header_->fec_flag);
   EXPECT_FALSE(visitor_.header_->entropy_flag);
   EXPECT_EQ(0, visitor_.header_->entropy_hash);
   EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
 
   // Now test framing boundaries.
   for (size_t i = 0;
        i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                !kIncludeVersion, !kIncludePathId,
                                !kIncludeDiversificationNonce,
@@ skipping 15 matching lines @@
       } else {
         expected_error = "Unable to read packet number.";
       }
     }
     CheckProcessingFails(
         framer_.version() <= QUIC_VERSION_33 ? packet : packet_34, i,
         expected_error, QUIC_INVALID_PACKET_HEADER);
   }
 }
 
+TEST_P(QuicFramerTest, PacketNumberDecreasesThenIncreases) {
+  FLAGS_quic_packet_numbers_largest_received = true;
+  // Test the case when a packet is received from the past and future packet
+  // numbers are still calculated relative to the largest received packet.
+  QuicPacketHeader header;
+  header.public_header.connection_id = kConnectionId;
+  header.public_header.reset_flag = false;
+  header.public_header.version_flag = false;
+  header.fec_flag = false;
+  header.entropy_flag = false;
+  header.packet_number = kPacketNumber - 2;
+
+  QuicPaddingFrame padding_frame;
+  QuicFrames frames;
+  frames.push_back(QuicFrame(padding_frame));
+  std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
+  ASSERT_TRUE(data != nullptr);
+
+  QuicEncryptedPacket encrypted(data->data(), data->length(), false);
+  EXPECT_TRUE(framer_.ProcessPacket(encrypted));
+  ASSERT_TRUE(visitor_.header_.get());
+  EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
+  EXPECT_EQ(PACKET_6BYTE_PACKET_NUMBER,
+            visitor_.header_->public_header.packet_number_length);
+  EXPECT_EQ(kPacketNumber - 2, visitor_.header_->packet_number);
+
+  // Receive a 1 byte packet number.
+  header.packet_number = kPacketNumber;
+  header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
+  data.reset(BuildDataPacket(header, frames));
+  QuicEncryptedPacket encrypted1(data->data(), data->length(), false);
+  EXPECT_TRUE(framer_.ProcessPacket(encrypted1));
+  ASSERT_TRUE(visitor_.header_.get());
+  EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
+  EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
+            visitor_.header_->public_header.packet_number_length);
+  EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
+
+  // Process a 2 byte packet number 256 packets ago.
+  header.packet_number = kPacketNumber - 256;
+  header.public_header.packet_number_length = PACKET_2BYTE_PACKET_NUMBER;
+  data.reset(BuildDataPacket(header, frames));
+  QuicEncryptedPacket encrypted2(data->data(), data->length(), false);
+  EXPECT_TRUE(framer_.ProcessPacket(encrypted2));
+  ASSERT_TRUE(visitor_.header_.get());
+  EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
+  EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER,
+            visitor_.header_->public_header.packet_number_length);
+  EXPECT_EQ(kPacketNumber - 256, visitor_.header_->packet_number);
+
+  // Process another 1 byte packet number and ensure it works.
+  header.packet_number = kPacketNumber - 1;
+  header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
+  data.reset(BuildDataPacket(header, frames));
+  QuicEncryptedPacket encrypted3(data->data(), data->length(), false);
+  EXPECT_TRUE(framer_.ProcessPacket(encrypted3));
+  ASSERT_TRUE(visitor_.header_.get());
+  EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
+  EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
+            visitor_.header_->public_header.packet_number_length);
+  EXPECT_EQ(kPacketNumber - 1, visitor_.header_->packet_number);
+}
+
 TEST_P(QuicFramerTest, InvalidPublicFlag) {
   if (framer_.version() > QUIC_VERSION_33) {
     return;
   }
   // clang-format off
   unsigned char packet[] = {
     // public flags: all flags set but the public reset flag and version flag.
     0xF8,
     // connection_id
     0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
@@ skipping 5767 matching lines @@
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
   // clang-format on
 
   QuicFramerFuzzFunc(packet, arraysize(packet));
 }
 
 }  // namespace test
 }  // namespace net