relnote: Deprecate flag quic_disable_pre_32

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 1686 matching lines @@
     0x98, 0xBA, 0xDC, 0xFE,
     // packet number
     0x01, 0x00, 0x00, 0x00,
     0x00, 0x00,
     // private flags (fec group)
     0x02,
     // first fec protected packet offset
     0x10
   };
   // clang-format on
-  if (framer_.version() > QUIC_VERSION_31) {
-    CheckProcessingFails(packet, arraysize(packet),
-                         "Illegal private flags value.",
-                         QUIC_INVALID_PACKET_HEADER);
-  } else {
-    CheckProcessingFails(packet, arraysize(packet),
-                         "First fec protected packet offset must be less "
-                         "than the packet number.",
-                         QUIC_INVALID_PACKET_HEADER);
-  }
+  CheckProcessingFails(packet, arraysize(packet),
+                       "Illegal private flags value.",
+                       QUIC_INVALID_PACKET_HEADER);
+
 };
 
 TEST_P(QuicFramerTest, PaddingFrame) {
   // clang-format off
   unsigned char packet[] = {
     // public flags (8 byte connection_id)
     0x38,
     // connection_id
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
@@ skipping 642 matching lines @@
   // clang-format on
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.public_header_.get());
   ASSERT_FALSE(visitor_.header_.get());
 }
 
-TEST_P(QuicFramerTest, AckFrameTwoTimestamp) {
-  // clang-format off
-  unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x38,
-    // connection_id
-    0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
-    // packet number
-    0xA8, 0x9A, 0x78, 0x56, 0x34, 0x12,
-    // private flags (entropy)
-    0x01,
-
-    // frame type (ack frame)
-    // (has nacks, not truncated, 6 byte largest observed, 1 byte delta)
-    0x6C,
-    // entropy hash of all received packets.
-    0xBA,
-    // largest observed packet number
-    0xBF, 0x9A, 0x78, 0x56, 0x34, 0x12,
-    // Zero delta time.
-    0x00, 0x00,
-    // Number of timestamps.
-    0x02,
-    // Delta from largest observed.
-    0x01,
-    // Delta time.
-    0x10, 0x32, 0x54, 0x76,
-    // Delta from largest observed.
-    0x02,
-    // Delta time.
-    0x10, 0x32,
-    // num missing packets
-    0x01,
-    // missing packet delta
-    0x01,
-    // 0 more missing packets in range.
-    0x00,
-    // Number of revived packets.
-    0x00,
-  };
-  // clang-format on
-
-  if (framer_.version() > QUIC_VERSION_31) {
-    return;
-  }
-
-  QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
-  EXPECT_TRUE(framer_.ProcessPacket(encrypted));
-
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
-  ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
-                              !kIncludeDiversificationNonce));
-
-  EXPECT_EQ(0u, visitor_.stream_frames_.size());
-  ASSERT_EQ(1u, visitor_.ack_frames_.size());
-  const QuicAckFrame& frame = *visitor_.ack_frames_[0];
-  EXPECT_EQ(0xBA, frame.entropy_hash);
-  EXPECT_EQ(kLargestObserved, frame.largest_observed);
-  ASSERT_EQ(1u, frame.packets.NumPacketsSlow());
-  ASSERT_EQ(2u, frame.received_packet_times.size());
-  EXPECT_EQ(kMissingPacket, frame.packets.Min());
-
-  const size_t kReceivedEntropyOffset = kQuicFrameTypeSize;
-  const size_t kLargestObservedOffset =
-      kReceivedEntropyOffset + kQuicEntropyHashSize;
-  const size_t kMissingDeltaTimeOffset =
-      kLargestObservedOffset + PACKET_6BYTE_PACKET_NUMBER;
-  const size_t kNumTimestampsOffset =
-      kMissingDeltaTimeOffset + kQuicDeltaTimeLargestObservedSize;
-  const size_t kTimestampDeltaLargestObserved1 =
-      kNumTimestampsOffset + kQuicNumTimestampsSize;
-  const size_t kTimestampTimeDeltaLargestObserved1 =
-      kTimestampDeltaLargestObserved1 + 1;
-  const size_t kTimestampDeltaLargestObserved2 =
-      kTimestampTimeDeltaLargestObserved1 + 4;
-  const size_t kTimestampTimeDeltaLargestObserved2 =
-      kTimestampDeltaLargestObserved2 + 1;
-  const size_t kNumMissingPacketOffset =
-      kTimestampTimeDeltaLargestObserved2 + 2;
-  const size_t kMissingPacketsOffset =
-      kNumMissingPacketOffset + kNumberOfNackRangesSize;
-  const size_t kMissingPacketsRange =
-      kMissingPacketsOffset + PACKET_1BYTE_PACKET_NUMBER;
-  const size_t kRevivedPacketsLength =
-      kMissingPacketsRange + PACKET_1BYTE_PACKET_NUMBER;
-  // Now test framing boundaries.
-  const size_t ack_frame_size =
-      kRevivedPacketsLength + PACKET_1BYTE_PACKET_NUMBER;
-  for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) {
-    string expected_error;
-    if (i < kLargestObservedOffset) {
-      expected_error = "Unable to read entropy hash for received packets.";
-    } else if (i < kMissingDeltaTimeOffset) {
-      expected_error = "Unable to read largest observed.";
-    } else if (i < kNumTimestampsOffset) {
-      expected_error = "Unable to read ack delay time.";
-    } else if (i < kTimestampDeltaLargestObserved1) {
-      expected_error = "Unable to read num received packets.";
-    } else if (i < kTimestampTimeDeltaLargestObserved1) {
-      expected_error = "Unable to read sequence delta in received packets.";
-    } else if (i < kTimestampDeltaLargestObserved2) {
-      expected_error = "Unable to read time delta in received packets.";
-    } else if (i < kTimestampTimeDeltaLargestObserved2) {
-      expected_error = "Unable to read sequence delta in received packets.";
-    } else if (i < kNumMissingPacketOffset) {
-      expected_error =
-          "Unable to read incremental time delta in received packets.";
-    } else if (i < kMissingPacketsOffset) {
-      expected_error = "Unable to read num missing packet ranges.";
-    } else if (i < kMissingPacketsRange) {
-      expected_error = "Unable to read missing packet number delta.";
-    } else if (i < kRevivedPacketsLength) {
-      expected_error = "Unable to read missing packet number range.";
-    } else {
-      expected_error = "Unable to read num revived packets.";
-    }
-    CheckProcessingFails(
-        packet,
-        i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
-                                !kIncludeVersion, !kIncludePathId,
-                                !kIncludeDiversificationNonce,
-                                PACKET_6BYTE_PACKET_NUMBER),
-        expected_error, QUIC_INVALID_ACK_DATA);
-  }
-}
-
 TEST_P(QuicFramerTest, AckFrameTwoTimestampVersion32) {
   // clang-format off
   unsigned char packet[] = {
     // public flags (8 byte connection_id)
     0x3C,
     // connection_id
     0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
     // packet number
     0xA8, 0x9A, 0x78, 0x56, 0x34, 0x12,
     // private flags (entropy)
@@ skipping 20 matching lines @@
     0x10, 0x32,
     // num missing packets
     0x01,
     // missing packet delta
     0x01,
     // 0 more missing packets in range.
     0x00,
   };
   // clang-format on
 
-  if (framer_.version() <= QUIC_VERSION_31 ||
-      framer_.version() > QUIC_VERSION_33) {
+  if (framer_.version() > QUIC_VERSION_33) {
     return;
   }
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
                               !kIncludeDiversificationNonce));
@@ skipping 55 matching lines @@
     CheckProcessingFails(
         packet,
         i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                 !kIncludeVersion, !kIncludePathId,
                                 !kIncludeDiversificationNonce,
                                 PACKET_6BYTE_PACKET_NUMBER),
         expected_error, QUIC_INVALID_ACK_DATA);
   }
 }
 
-TEST_P(QuicFramerTest, AckFrameOneTimestamp) {
+TEST_P(QuicFramerTest, AckFrameOneTimestampVersion32) {
   // clang-format off
   unsigned char packet[] = {
       // public flags (8 byte connection_id)
-      0x38,
+      0x3C,
       // connection_id
       0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
       // packet number
       0xA8, 0x9A, 0x78, 0x56, 0x34, 0x12,
       // private flags (entropy)
       0x01,
 
       // frame type (ack frame)
       // (has nacks, not truncated, 6 byte largest observed, 1 byte delta)
       0x6C,
       // entropy hash of all received packets.
       0xBA,
       // largest observed packet number
       0xBF, 0x9A, 0x78, 0x56, 0x34, 0x12,
       // Zero delta time.
       0x00, 0x00,
       // Number of timestamps.
       0x01,
       // Delta from largest observed.
       0x01,
       // Delta time.
       0x10, 0x32, 0x54, 0x76,
       // num missing packets
       0x01,
       // missing packet delta
       0x01,
       // 0 more missing packets in range.
       0x00,
-      // Number of revived packets.
-      0x00,
   };
   // clang-format on
 
-  if (framer_.version() > QUIC_VERSION_31) {
+  if (framer_.version() > QUIC_VERSION_33) {
     return;
   }
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
                               !kIncludeDiversificationNonce));
@@ skipping 14 matching lines @@
       kLargestObservedOffset + PACKET_6BYTE_PACKET_NUMBER;
   const size_t kNumTimestampsOffset =
       kMissingDeltaTimeOffset + kQuicDeltaTimeLargestObservedSize;
   const size_t kTimestampDeltaLargestObserved =
       kNumTimestampsOffset + kQuicNumTimestampsSize;
   const size_t kTimestampTimeDeltaLargestObserved =
       kTimestampDeltaLargestObserved + 1;
   const size_t kNumMissingPacketOffset = kTimestampTimeDeltaLargestObserved + 4;
   const size_t kMissingPacketsOffset =
       kNumMissingPacketOffset + kNumberOfNackRangesSize;
-  const size_t kMissingPacketsRange =
-      kMissingPacketsOffset + PACKET_1BYTE_PACKET_NUMBER;
-  const size_t kRevivedPacketsLength =
-      kMissingPacketsRange + PACKET_1BYTE_PACKET_NUMBER;
   // Now test framing boundaries.
-  const size_t ack_frame_size =
-      kRevivedPacketsLength + PACKET_1BYTE_PACKET_NUMBER;
+  const size_t ack_frame_size = PACKET_1BYTE_PACKET_NUMBER;
   for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) {
     string expected_error;
     if (i < kLargestObservedOffset) {
       expected_error = "Unable to read entropy hash for received packets.";
     } else if (i < kMissingDeltaTimeOffset) {
       expected_error = "Unable to read largest observed.";
     } else if (i < kNumTimestampsOffset) {
       expected_error = "Unable to read ack delay time.";
     } else if (i < kTimestampDeltaLargestObserved) {
       expected_error = "Unable to read num received packets.";
     } else if (i < kTimestampTimeDeltaLargestObserved) {
       expected_error = "Unable to read sequence delta in received packets.";
     } else if (i < kNumMissingPacketOffset) {
       expected_error = "Unable to read time delta in received packets.";
     } else if (i < kMissingPacketsOffset) {
       expected_error = "Unable to read num missing packet ranges.";
-    } else if (i < kMissingPacketsRange) {
+    } else {
       expected_error = "Unable to read missing packet number delta.";
-    } else if (i < kRevivedPacketsLength) {
-      expected_error = "Unable to read missing packet number range.";
-    } else {
-      expected_error = "Unable to read num revived packets.";
     }
     CheckProcessingFails(
         packet,
         i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                 !kIncludeVersion, !kIncludePathId,
                                 !kIncludeDiversificationNonce,
                                 PACKET_6BYTE_PACKET_NUMBER),
         expected_error, QUIC_INVALID_ACK_DATA);
   }
 }
 
-TEST_P(QuicFramerTest, AckFrameOneTimestampVersion32) {
+TEST_P(QuicFramerTest, NewAckFrameOneAckBlock) {
   // clang-format off
   unsigned char packet[] = {
       // public flags (8 byte connection_id)
       0x3C,
       // connection_id
       0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
       // packet number
-      0xA8, 0x9A, 0x78, 0x56, 0x34, 0x12,
-      // private flags (entropy)
-      0x01,
+      0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
 
       // frame type (ack frame)
-      // (has nacks, not truncated, 6 byte largest observed, 1 byte delta)
-      0x6C,
-      // entropy hash of all received packets.
-      0xBA,
-      // largest observed packet number
-      0xBF, 0x9A, 0x78, 0x56, 0x34, 0x12,
+      // (one ack block, 2 byte largest observed, 2 byte block length)
+      0x45,
+      // largest acked
+      0x34, 0x12,
       // Zero delta time.
       0x00, 0x00,
-      // Number of timestamps.
-      0x01,
-      // Delta from largest observed.
-      0x01,
-      // Delta time.
-      0x10, 0x32, 0x54, 0x76,
-      // num missing packets
-      0x01,
-      // missing packet delta
-      0x01,
-      // 0 more missing packets in range.
+      // first ack block length.
+      0x34, 0x12,
+      // num timestamps.
       0x00,
   };
   // clang-format on
 
-  if (framer_.version() <= QUIC_VERSION_31 ||
-      framer_.version() > QUIC_VERSION_33) {
+  if (framer_.version() <= QUIC_VERSION_33) {
     return;
   }
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
                               !kIncludeDiversificationNonce));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
   const QuicAckFrame& frame = *visitor_.ack_frames_[0];
-  EXPECT_EQ(0xBA, frame.entropy_hash);
-  EXPECT_EQ(kLargestObserved, frame.largest_observed);
-  ASSERT_EQ(1u, frame.packets.NumPacketsSlow());
-  ASSERT_EQ(1u, frame.received_packet_times.size());
-  EXPECT_EQ(kMissingPacket, frame.packets.Min());
+  EXPECT_EQ(kSmallLargestObserved, frame.largest_observed);
+  EXPECT_FALSE(frame.missing);
+  ASSERT_EQ(4660u, frame.packets.NumPacketsSlow());
 
-  const size_t kReceivedEntropyOffset = kQuicFrameTypeSize;
-  const size_t kLargestObservedOffset =
-      kReceivedEntropyOffset + kQuicEntropyHashSize;
-  const size_t kMissingDeltaTimeOffset =
-      kLargestObservedOffset + PACKET_6BYTE_PACKET_NUMBER;
+  const size_t kLargestAckedOffset = kQuicFrameTypeSize;
+  const size_t kLargestAckedDeltaTimeOffset =
+      kLargestAckedOffset + PACKET_2BYTE_PACKET_NUMBER;
+  const size_t kFirstAckBlockLengthOffset =
+      kLargestAckedDeltaTimeOffset + kQuicDeltaTimeLargestObservedSize;
   const size_t kNumTimestampsOffset =
-      kMissingDeltaTimeOffset + kQuicDeltaTimeLargestObservedSize;
-  const size_t kTimestampDeltaLargestObserved =
-      kNumTimestampsOffset + kQuicNumTimestampsSize;
-  const size_t kTimestampTimeDeltaLargestObserved =
-      kTimestampDeltaLargestObserved + 1;
-  const size_t kNumMissingPacketOffset = kTimestampTimeDeltaLargestObserved + 4;
-  const size_t kMissingPacketsOffset =
-      kNumMissingPacketOffset + kNumberOfNackRangesSize;
+      kFirstAckBlockLengthOffset + PACKET_2BYTE_PACKET_NUMBER;
   // Now test framing boundaries.
-  const size_t ack_frame_size = PACKET_1BYTE_PACKET_NUMBER;
+  const size_t ack_frame_size =
+      kFirstAckBlockLengthOffset + PACKET_2BYTE_PACKET_NUMBER;
   for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) {
     string expected_error;
-    if (i < kLargestObservedOffset) {
-      expected_error = "Unable to read entropy hash for received packets.";
-    } else if (i < kMissingDeltaTimeOffset) {
-      expected_error = "Unable to read largest observed.";
+    if (i < kLargestAckedDeltaTimeOffset) {
+      expected_error = "Unable to read largest acked.";
+    } else if (i < kFirstAckBlockLengthOffset) {
+      expected_error = "Unable to read ack delay time.";
     } else if (i < kNumTimestampsOffset) {
-      expected_error = "Unable to read ack delay time.";
-    } else if (i < kTimestampDeltaLargestObserved) {
+      expected_error = "Unable to read first ack block length.";
+    } else {
       expected_error = "Unable to read num received packets.";
-    } else if (i < kTimestampTimeDeltaLargestObserved) {
-      expected_error = "Unable to read sequence delta in received packets.";
-    } else if (i < kNumMissingPacketOffset) {
-      expected_error = "Unable to read time delta in received packets.";
-    } else if (i < kMissingPacketsOffset) {
-      expected_error = "Unable to read num missing packet ranges.";
-    } else {
-      expected_error = "Unable to read missing packet number delta.";
     }
     CheckProcessingFails(
         packet,
         i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                 !kIncludeVersion, !kIncludePathId,
                                 !kIncludeDiversificationNonce,
                                 PACKET_6BYTE_PACKET_NUMBER),
         expected_error, QUIC_INVALID_ACK_DATA);
   }
 }
 
-TEST_P(QuicFramerTest, AckFrame) {
+TEST_P(QuicFramerTest, NewAckFrameTwoTimeStampsMultipleAckBlocks) {
   // clang-format off
   unsigned char packet[] = {
       // public flags (8 byte connection_id)
       0x3C,
       // connection_id
       0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
       // packet number
-      0xA8, 0x9A, 0x78, 0x56, 0x34, 0x12,
-      // private flags (entropy)
-      0x01,
-
-      // frame type (ack frame)
-      // (has nacks, not truncated, 6 byte largest observed, 1 byte delta)
-      0x6C,
-      // entropy hash of all received packets.
-      0xBA,
-      // largest observed packet number
-      0xBF, 0x9A, 0x78, 0x56, 0x34, 0x12,
-      // Zero delta time.
-      0x00, 0x00,
-      // Number of timestamps.
-      0x00,
-      // num missing packets
-      0x01,
-      // missing packet delta
-      0x01,
-      // 0 more missing packets in range.
-      0x00,
-      // Number of revived packets.
-      0x00,
-  };
-  // clang-format on
-
-  if (framer_.version() > QUIC_VERSION_31) {
-    return;
-  }
-
-  QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
-  EXPECT_TRUE(framer_.ProcessPacket(encrypted));
-
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
-  ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
-                              !kIncludeDiversificationNonce));
-
-  EXPECT_EQ(0u, visitor_.stream_frames_.size());
-  ASSERT_EQ(1u, visitor_.ack_frames_.size());
-  const QuicAckFrame& frame = *visitor_.ack_frames_[0];
-  EXPECT_EQ(0xBA, frame.entropy_hash);
-  EXPECT_EQ(kLargestObserved, frame.largest_observed);
-  ASSERT_EQ(1u, frame.packets.NumPacketsSlow());
-  EXPECT_EQ(kMissingPacket, frame.packets.Min());
-
-  const size_t kReceivedEntropyOffset = kQuicFrameTypeSize;
-  const size_t kLargestObservedOffset =
-      kReceivedEntropyOffset + kQuicEntropyHashSize;
-  const size_t kMissingDeltaTimeOffset =
-      kLargestObservedOffset + PACKET_6BYTE_PACKET_NUMBER;
-  const size_t kNumTimestampsOffset =
-      kMissingDeltaTimeOffset + kQuicDeltaTimeLargestObservedSize;
-  const size_t kNumMissingPacketOffset =
-      kNumTimestampsOffset + kQuicNumTimestampsSize;
-  const size_t kMissingPacketsOffset =
-      kNumMissingPacketOffset + kNumberOfNackRangesSize;
-  const size_t kMissingPacketsRange =
-      kMissingPacketsOffset + PACKET_1BYTE_PACKET_NUMBER;
-  const size_t kRevivedPacketsLength =
-      kMissingPacketsRange + PACKET_1BYTE_PACKET_NUMBER;
-  // Now test framing boundaries.
-  const size_t ack_frame_size =
-      kRevivedPacketsLength + PACKET_1BYTE_PACKET_NUMBER;
-  for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) {
-    string expected_error;
-    if (i < kLargestObservedOffset) {
-      expected_error = "Unable to read entropy hash for received packets.";
-    } else if (i < kMissingDeltaTimeOffset) {
-      expected_error = "Unable to read largest observed.";
-    } else if (i < kNumTimestampsOffset) {
-      expected_error = "Unable to read ack delay time.";
-    } else if (i < kNumMissingPacketOffset) {
-      expected_error = "Unable to read num received packets.";
-    } else if (i < kMissingPacketsOffset) {
-      expected_error = "Unable to read num missing packet ranges.";
-    } else if (i < kMissingPacketsRange) {
-      expected_error = "Unable to read missing packet number delta.";
-    } else if (i < kRevivedPacketsLength) {
-      expected_error = "Unable to read missing packet number range.";
-    } else {
-      expected_error = "Unable to read num revived packets.";
-    }
-    CheckProcessingFails(
-        packet,
-        i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
-                                !kIncludeVersion, !kIncludePathId,
-                                !kIncludeDiversificationNonce,
-                                PACKET_6BYTE_PACKET_NUMBER),
-        expected_error, QUIC_INVALID_ACK_DATA);
-  }
-}
-
-TEST_P(QuicFramerTest, NewAckFrameOneAckBlock) {
-  // clang-format off
-  unsigned char packet[] = {
-      // public flags (8 byte connection_id)
-      0x3C,
-      // connection_id
-      0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
-      // packet number
-      0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
-
-      // frame type (ack frame)
-      // (one ack block, 2 byte largest observed, 2 byte block length)
-      0x45,
-      // largest acked
-      0x34, 0x12,
-      // Zero delta time.
-      0x00, 0x00,
-      // first ack block length.
-      0x34, 0x12,
-      // num timestamps.
-      0x00,
-  };
-  // clang-format on
-
-  if (framer_.version() <= QUIC_VERSION_33) {
-    return;
-  }
-
-  QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
-  EXPECT_TRUE(framer_.ProcessPacket(encrypted));
-
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
-  ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
-                              !kIncludeDiversificationNonce));
-
-  EXPECT_EQ(0u, visitor_.stream_frames_.size());
-  ASSERT_EQ(1u, visitor_.ack_frames_.size());
-  const QuicAckFrame& frame = *visitor_.ack_frames_[0];
-  EXPECT_EQ(kSmallLargestObserved, frame.largest_observed);
-  EXPECT_FALSE(frame.missing);
-  ASSERT_EQ(4660u, frame.packets.NumPacketsSlow());
-
-  const size_t kLargestAckedOffset = kQuicFrameTypeSize;
-  const size_t kLargestAckedDeltaTimeOffset =
-      kLargestAckedOffset + PACKET_2BYTE_PACKET_NUMBER;
-  const size_t kFirstAckBlockLengthOffset =
-      kLargestAckedDeltaTimeOffset + kQuicDeltaTimeLargestObservedSize;
-  const size_t kNumTimestampsOffset =
-      kFirstAckBlockLengthOffset + PACKET_2BYTE_PACKET_NUMBER;
-  // Now test framing boundaries.
-  const size_t ack_frame_size =
-      kFirstAckBlockLengthOffset + PACKET_2BYTE_PACKET_NUMBER;
-  for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) {
-    string expected_error;
-    if (i < kLargestAckedDeltaTimeOffset) {
-      expected_error = "Unable to read largest acked.";
-    } else if (i < kFirstAckBlockLengthOffset) {
-      expected_error = "Unable to read ack delay time.";
-    } else if (i < kNumTimestampsOffset) {
-      expected_error = "Unable to read first ack block length.";
-    } else {
-      expected_error = "Unable to read num received packets.";
-    }
-    CheckProcessingFails(
-        packet,
-        i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
-                                !kIncludeVersion, !kIncludePathId,
-                                !kIncludeDiversificationNonce,
-                                PACKET_6BYTE_PACKET_NUMBER),
-        expected_error, QUIC_INVALID_ACK_DATA);
-  }
-}
-
-TEST_P(QuicFramerTest, NewAckFrameTwoTimeStampsMultipleAckBlocks) {
-  // clang-format off
-  unsigned char packet[] = {
-      // public flags (8 byte connection_id)
-      0x3C,
-      // connection_id
-      0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
-      // packet number
       0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
 
       // frame type (ack frame)
       // (more than one ack block, 2 byte largest observed, 2 byte block length)
       0x65,
       // largest acked
       0x34, 0x12,
       // Zero delta time.
       0x00, 0x00,
       // num ack blocks ranges.
@@ skipping 131 matching lines @@
 }
 
 TEST_P(QuicFramerTest, AckFrameVersion32) {
   // clang-format off
   unsigned char packet[] = {
       // public flags (8 byte connection_id)
       0x38,
       // connection_id
       0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
       // packet number
-      0xA8, 0x9A, 0x78, 0x56, 0x34, 0x12,
-      // private flags (entropy)
-      0x01,
-
-      // frame type (ack frame)
-      // (has nacks, not truncated, 6 byte largest observed, 1 byte delta)
-      0x6C,
-      // entropy hash of all received packets.
-      0xBA,
-      // largest observed packet number
-      0xBF, 0x9A, 0x78, 0x56, 0x34, 0x12,
-      // Zero delta time.
-      0x00, 0x00,
-      // Number of timestamps.
-      0x00,
-      // num missing packets
-      0x01,
-      // missing packet delta
-      0x01,
-      // 0 more missing packets in range.
-      0x00,
-  };
-  // clang-format on
-
-  if (framer_.version() <= QUIC_VERSION_31 ||
-      framer_.version() > QUIC_VERSION_33) {
-    return;
-  }
-
-  QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
-  EXPECT_TRUE(framer_.ProcessPacket(encrypted));
-
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
-  ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
-                              !kIncludeDiversificationNonce));
-
-  EXPECT_EQ(0u, visitor_.stream_frames_.size());
-  ASSERT_EQ(1u, visitor_.ack_frames_.size());
-  const QuicAckFrame& frame = *visitor_.ack_frames_[0];
-  EXPECT_EQ(0xBA, frame.entropy_hash);
-  EXPECT_EQ(kLargestObserved, frame.largest_observed);
-  ASSERT_EQ(1u, frame.packets.NumPacketsSlow());
-  EXPECT_EQ(kMissingPacket, frame.packets.Min());
-
-  const size_t kReceivedEntropyOffset = kQuicFrameTypeSize;
-  const size_t kLargestObservedOffset =
-      kReceivedEntropyOffset + kQuicEntropyHashSize;
-  const size_t kMissingDeltaTimeOffset =
-      kLargestObservedOffset + PACKET_6BYTE_PACKET_NUMBER;
-  const size_t kNumTimestampsOffset =
-      kMissingDeltaTimeOffset + kQuicDeltaTimeLargestObservedSize;
-  const size_t kNumMissingPacketOffset =
-      kNumTimestampsOffset + kQuicNumTimestampsSize;
-  const size_t kMissingPacketsOffset =
-      kNumMissingPacketOffset + kNumberOfNackRangesSize;
-  // Now test framing boundaries.
-  const size_t ack_frame_size = PACKET_1BYTE_PACKET_NUMBER;
-  for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) {
-    string expected_error;
-    if (i < kLargestObservedOffset) {
-      expected_error = "Unable to read entropy hash for received packets.";
-    } else if (i < kMissingDeltaTimeOffset) {
-      expected_error = "Unable to read largest observed.";
-    } else if (i < kNumTimestampsOffset) {
-      expected_error = "Unable to read ack delay time.";
-    } else if (i < kNumMissingPacketOffset) {
-      expected_error = "Unable to read num received packets.";
-    } else if (i < kMissingPacketsOffset) {
-      expected_error = "Unable to read num missing packet ranges.";
-    } else {
-      expected_error = "Unable to read missing packet number delta.";
-    }
-    CheckProcessingFails(
-        packet,
-        i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
-                                !kIncludeVersion, !kIncludePathId,
-                                !kIncludeDiversificationNonce,
-                                PACKET_6BYTE_PACKET_NUMBER),
-        expected_error, QUIC_INVALID_ACK_DATA);
-  }
-}
-
-TEST_P(QuicFramerTest, AckFrameRevivedPackets) {
-  // clang-format off
-  unsigned char packet[] = {
-      // public flags (8 byte connection_id)
-      0x38,
-      // connection_id
-      0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
-      // packet number
-      0xA8, 0x9A, 0x78, 0x56, 0x34, 0x12,
-      // private flags (entropy)
-      0x01,
-
-      // frame type (ack frame)
-      // (has nacks, not truncated, 6 byte largest observed, 1 byte delta)
-      0x6C,
-      // entropy hash of all received packets.
-      0xBA,
-      // largest observed packet number
-      0xBF, 0x9A, 0x78, 0x56, 0x34, 0x12,
-      // Zero delta time.
-      0x00, 0x00,
-      // num received packets.
-      0x00,
-      // num missing packets
-      0x01,
-      // missing packet delta
-      0x01,
-      // 0 more missing packets in range.
-      0x00,
-      // Number of revived packets.
-      0x01,
-      // Revived packet number.
-      0xBE, 0x9A, 0x78, 0x56, 0x34, 0x12,
-      // Number of revived packets.
-      0x00,
-  };
-  // clang-format on
-
-  if (framer_.version() > QUIC_VERSION_31) {
-    return;
-  }
-
-  QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
-  EXPECT_TRUE(framer_.ProcessPacket(encrypted));
-
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
-  ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
-                              !kIncludeDiversificationNonce));
-
-  EXPECT_EQ(0u, visitor_.stream_frames_.size());
-  ASSERT_EQ(1u, visitor_.ack_frames_.size());
-  const QuicAckFrame& frame = *visitor_.ack_frames_[0];
-  EXPECT_EQ(0xBA, frame.entropy_hash);
-  EXPECT_EQ(kLargestObserved, frame.largest_observed);
-  ASSERT_EQ(1u, frame.packets.NumPacketsSlow());
-  EXPECT_EQ(kMissingPacket, frame.packets.Min());
-
-  const size_t kReceivedEntropyOffset = kQuicFrameTypeSize;
-  const size_t kLargestObservedOffset =
-      kReceivedEntropyOffset + kQuicEntropyHashSize;
-  const size_t kMissingDeltaTimeOffset =
-      kLargestObservedOffset + PACKET_6BYTE_PACKET_NUMBER;
-  const size_t kNumTimestampsOffset =
-      kMissingDeltaTimeOffset + kQuicDeltaTimeLargestObservedSize;
-  const size_t kNumMissingPacketOffset =
-      kNumTimestampsOffset + kQuicNumTimestampsSize;
-  const size_t kMissingPacketsOffset =
-      kNumMissingPacketOffset + kNumberOfNackRangesSize;
-  const size_t kMissingPacketsRange =
-      kMissingPacketsOffset + PACKET_1BYTE_PACKET_NUMBER;
-  const size_t kRevivedPacketsLength =
-      kMissingPacketsRange + PACKET_1BYTE_PACKET_NUMBER;
-  const size_t kRevivedPacketSequenceNumberLength =
-      kRevivedPacketsLength + PACKET_1BYTE_PACKET_NUMBER;
-  // Now test framing boundaries.
-  const size_t ack_frame_size =
-      kRevivedPacketSequenceNumberLength + PACKET_6BYTE_PACKET_NUMBER;
-  for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) {
-    string expected_error;
-    if (i < kReceivedEntropyOffset) {
-      expected_error = "Unable to read least unacked delta.";
-    } else if (i < kLargestObservedOffset) {
-      expected_error = "Unable to read entropy hash for received packets.";
-    } else if (i < kMissingDeltaTimeOffset) {
-      expected_error = "Unable to read largest observed.";
-    } else if (i < kNumTimestampsOffset) {
-      expected_error = "Unable to read ack delay time.";
-    } else if (i < kNumMissingPacketOffset) {
-      expected_error = "Unable to read num received packets.";
-    } else if (i < kMissingPacketsOffset) {
-      expected_error = "Unable to read num missing packet ranges.";
-    } else if (i < kMissingPacketsRange) {
-      expected_error = "Unable to read missing packet number delta.";
-    } else if (i < kRevivedPacketsLength) {
-      expected_error = "Unable to read missing packet number range.";
-    } else if (i < kRevivedPacketSequenceNumberLength) {
-      expected_error = "Unable to read num revived packets.";
-    } else {
-      expected_error = "Unable to read revived packet.";
-    }
-    CheckProcessingFails(
-        packet,
-        i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
-                                !kIncludeVersion, !kIncludePathId,
-                                !kIncludeDiversificationNonce,
-                                PACKET_6BYTE_PACKET_NUMBER),
-        expected_error, QUIC_INVALID_ACK_DATA);
-  }
-}
-
-TEST_P(QuicFramerTest, AckFrameNoNacks) {
-  // clang-format off
-  unsigned char packet[] = {
-      // public flags (8 byte connection_id)
-      static_cast<unsigned char>(
-          framer_.version() > QUIC_VERSION_32 ? 0x38 : 0x3C),
-      // connection_id
-      0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
-      // packet number
-      0xA8, 0x9A, 0x78, 0x56, 0x34, 0x12,
-      // private flags (entropy)
-      0x01,
-
-      // frame type (ack frame)
-      // (no nacks, not truncated, 6 byte largest observed, 1 byte delta)
-      0x4C,
-      // entropy hash of all received packets.
-      0xBA,
-      // largest observed packet number
-      0xBF, 0x9A, 0x78, 0x56, 0x34, 0x12,
-      // Zero delta time.
-      0x00, 0x00,
-      // Number of received packets.
-      0x00,
-  };
-  // clang-format on
-  if (framer_.version() >= QUIC_VERSION_31) {
-    return;
-  }
-
-  QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
-  EXPECT_TRUE(framer_.ProcessPacket(encrypted));
-
-  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
-  ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
-                              !kIncludeDiversificationNonce));
-
-  EXPECT_EQ(0u, visitor_.stream_frames_.size());
-  ASSERT_EQ(1u, visitor_.ack_frames_.size());
-  QuicAckFrame* frame = visitor_.ack_frames_[0];
-  EXPECT_EQ(0xBA, frame->entropy_hash);
-  EXPECT_EQ(kLargestObserved, frame->largest_observed);
-  ASSERT_TRUE(frame->packets.Empty());
-
-  // Verify that the packet re-serializes identically.
-  QuicFrames frames;
-  frames.push_back(QuicFrame(frame));
-  std::unique_ptr<QuicPacket> data(BuildDataPacket(*visitor_.header_, frames));
-  ASSERT_TRUE(data != nullptr);
-
-  test::CompareCharArraysWithHexError("constructed packet", data->data(),
-                                      data->length(), AsChars(packet),
-                                      arraysize(packet));
-}
-
-TEST_P(QuicFramerTest, AckFrame500Nacks) {
-  // clang-format off
-  unsigned char packet[] = {
-      // public flags (8 byte connection_id)
-      static_cast<unsigned char>(
-          framer_.version() > QUIC_VERSION_32 ? 0x38 : 0x3C),
-      // connection_id
-      0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
-      // packet number
       0xA8, 0x9A, 0x78, 0x56, 0x34, 0x12,
       // private flags (entropy)
       0x01,
 
       // frame type (ack frame)
       // (has nacks, not truncated, 6 byte largest observed, 1 byte delta)
       0x6C,
       // entropy hash of all received packets.
       0xBA,
       // largest observed packet number
       0xBF, 0x9A, 0x78, 0x56, 0x34, 0x12,
       // Zero delta time.
       0x00, 0x00,
-      // No received packets.
+      // Number of timestamps.
       0x00,
-      // num missing packet ranges
-      0x02,
+      // num missing packets
+      0x01,
       // missing packet delta
       0x01,
-      // 243 more missing packets in range.
-      // The ranges are listed in this order so the re-constructed packet
-      // matches.
-      0xF3,
-      // No gap between ranges
-      0x00,
-      // 255 more missing packets in range.
-      0xFF,
-      // No revived packets.
+      // 0 more missing packets in range.
       0x00,
   };
   // clang-format on
 
-  if (framer_.version() > QUIC_VERSION_31) {
+  if (framer_.version() > QUIC_VERSION_33) {
     return;
   }
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
                               !kIncludeDiversificationNonce));
 
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
-  QuicAckFrame* frame = visitor_.ack_frames_[0];
-  EXPECT_EQ(0xBA, frame->entropy_hash);
-  EXPECT_EQ(kLargestObserved, frame->largest_observed);
-  ASSERT_EQ(500u, frame->packets.NumPacketsSlow());
-  EXPECT_EQ(kMissingPacket - 499, frame->packets.Min());
-  EXPECT_EQ(kMissingPacket, frame->packets.Max());
+  const QuicAckFrame& frame = *visitor_.ack_frames_[0];
+  EXPECT_EQ(0xBA, frame.entropy_hash);
+  EXPECT_EQ(kLargestObserved, frame.largest_observed);
+  ASSERT_EQ(1u, frame.packets.NumPacketsSlow());
+  EXPECT_EQ(kMissingPacket, frame.packets.Min());
 
-  // Verify that the packet re-serializes identically.
-  QuicFrames frames;
-  frames.push_back(QuicFrame(frame));
-  std::unique_ptr<QuicPacket> data(BuildDataPacket(*visitor_.header_, frames));
-  ASSERT_TRUE(data != nullptr);
-
-  test::CompareCharArraysWithHexError("constructed packet", data->data(),
-                                      data->length(), AsChars(packet),
-                                      arraysize(packet));
+  const size_t kReceivedEntropyOffset = kQuicFrameTypeSize;
+  const size_t kLargestObservedOffset =
+      kReceivedEntropyOffset + kQuicEntropyHashSize;
+  const size_t kMissingDeltaTimeOffset =
+      kLargestObservedOffset + PACKET_6BYTE_PACKET_NUMBER;
+  const size_t kNumTimestampsOffset =
+      kMissingDeltaTimeOffset + kQuicDeltaTimeLargestObservedSize;
+  const size_t kNumMissingPacketOffset =
+      kNumTimestampsOffset + kQuicNumTimestampsSize;
+  const size_t kMissingPacketsOffset =
+      kNumMissingPacketOffset + kNumberOfNackRangesSize;
+  // Now test framing boundaries.
+  const size_t ack_frame_size = PACKET_1BYTE_PACKET_NUMBER;
+  for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) {
+    string expected_error;
+    if (i < kLargestObservedOffset) {
+      expected_error = "Unable to read entropy hash for received packets.";
+    } else if (i < kMissingDeltaTimeOffset) {
+      expected_error = "Unable to read largest observed.";
+    } else if (i < kNumTimestampsOffset) {
+      expected_error = "Unable to read ack delay time.";
+    } else if (i < kNumMissingPacketOffset) {
+      expected_error = "Unable to read num received packets.";
+    } else if (i < kMissingPacketsOffset) {
+      expected_error = "Unable to read num missing packet ranges.";
+    } else {
+      expected_error = "Unable to read missing packet number delta.";
+    }
+    CheckProcessingFails(
+        packet,
+        i + GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
+                                !kIncludeVersion, !kIncludePathId,
+                                !kIncludeDiversificationNonce,
+                                PACKET_6BYTE_PACKET_NUMBER),
+        expected_error, QUIC_INVALID_ACK_DATA);
+  }
 }
 
 TEST_P(QuicFramerTest, AckFrame500NacksVersion32) {
   // clang-format off
   unsigned char packet[] = {
       // public flags (8 byte connection_id)
       static_cast<unsigned char>(
           framer_.version() > QUIC_VERSION_32 ? 0x38 : 0x3C),
       // connection_id
       0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
@@ skipping 21 matching lines @@
       // The ranges are listed in this order so the re-constructed packet
       // matches.
       0xF3,
       // No gap between ranges
       0x00,
       // 255 more missing packets in range.
       0xFF,
   };
   // clang-format on
 
-  if (framer_.version() <= QUIC_VERSION_31 ||
-      framer_.version() > QUIC_VERSION_33) {
+  if (framer_.version() > QUIC_VERSION_33) {
     return;
   }
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, !kIncludePathId,
                               !kIncludeDiversificationNonce));
@@ skipping 985 matching lines @@
     // redundancy
     'a',  'b',  'c',  'd',
     'e',  'f',  'g',  'h',
     'i',  'j',  'k',  'l',
     'm',  'n',  'o',  'p',
   };
   if (framer_.version() > QUIC_VERSION_33) {
     return;
   }
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
-  if (framer_.version() <= QUIC_VERSION_31) {
-    EXPECT_TRUE(framer_.ProcessPacket(encrypted));
-    EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
-  } else {
-    EXPECT_FALSE(framer_.ProcessPacket(encrypted));
-    EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, framer_.error());
-  }
+  EXPECT_FALSE(framer_.ProcessPacket(encrypted));
+  EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, framer_.error());
   EXPECT_FALSE(visitor_.header_.get());
 }
 
 TEST_P(QuicFramerTest, BuildPaddingFramePacket) {
   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;
@@ skipping 602 matching lines @@
   ack_frame.largest_observed = kLargestObserved;
   ack_frame.ack_delay_time = QuicTime::Delta::Zero();
   ack_frame.packets.Add(kMissingPacket);
 
   QuicFrames frames;
   frames.push_back(QuicFrame(&ack_frame));
 
   // clang-format off
   unsigned char packet[] = {
       // public flags (8 byte connection_id)
-      0x3C,
-      // connection_id
-      0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
-      // packet number
-      0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
-      // private flags (entropy)
-      0x01,
-
-      // frame type (ack frame)
-      // (has nacks, not truncated, 6 byte largest observed, 1 byte delta)
-      0x6C,
-      // entropy hash of all received packets.
-      0x43,
-      // largest observed packet number
-      0xBF, 0x9A, 0x78, 0x56, 0x34, 0x12,
-      // Zero delta time.
-      0x00, 0x00,
-      // num received packets.
-      0x00,
-      // num missing packet ranges
-      0x01,
-      // missing packet delta
-      0x01,
-      // 0 more missing packets in range.
-      0x00,
-      // 0 revived packets.
-      0x00,
-  };
-  // clang-format on
-
-  // clang-format off
-  unsigned char packet_version32[] = {
-      // public flags (8 byte connection_id)
       static_cast<unsigned char>(
           framer_.version() > QUIC_VERSION_32 ? 0x38 : 0x3C),
       // connection_id
       0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
       // packet number
       0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
       // private flags (entropy)
       0x01,
 
       // frame type (ack frame)
@@ skipping 12 matching lines @@
       // missing packet delta
       0x01,
       // 0 more missing packets in range.
       0x00,
   };
   // clang-format on
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
-  if (framer_.version() <= QUIC_VERSION_31) {
-    test::CompareCharArraysWithHexError("constructed packet", data->data(),
-                                        data->length(), AsChars(packet),
-                                        arraysize(packet));
-  } else {
-    test::CompareCharArraysWithHexError(
-        "constructed packet", data->data(), data->length(),
-        AsChars(packet_version32), arraysize(packet_version32));
-  }
+  test::CompareCharArraysWithHexError(
+      "constructed packet", data->data(), data->length(),
+      AsChars(packet), arraysize(packet));
 }
 
 // TODO(jri): Add test for tuncated packets in which the original ack frame had
 // revived packets. (In both the large and small packet cases below).
 
 TEST_P(QuicFramerTest, BuildTruncatedAckFrameLargePacket) {
   if (framer_.version() > QUIC_VERSION_33) {
     return;
   }
 
@@ skipping 15 matching lines @@
   for (size_t i = 1; i < 2 * 300; i += 2) {
     ack_frame.packets.Add(i);
   }
 
   QuicFrames frames;
   frames.push_back(QuicFrame(&ack_frame));
 
   // clang-format off
   unsigned char packet[] = {
       // public flags (8 byte connection_id)
-      0x3C,
-      // connection_id
-      0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
-      // packet number
-      0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
-      // private flags (entropy)
-      0x01,
-
-      // frame type (ack frame)
-      // (has nacks, is truncated, 2 byte largest observed, 1 byte delta)
-      0x74,
-      // entropy hash of all received packets, set to 1 by TestEntropyCalculator
-      // since ack is truncated.
-      0x01,
-      // 2-byte largest observed packet number.
-      // Expected to be 510 (0x1FE), since only 255 nack ranges can fit.
-      0xFE, 0x01,
-      // Zero delta time.
-      0x00, 0x00,
-      // num missing packet ranges (limited to 255 by size of this field).
-      0xFF,
-      // {missing packet delta, further missing packets in range}
-      // 6 nack ranges x 42 + 3 nack ranges
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-
-      // 0 revived packets.
-      0x00,
-  };
-  // clang-format on
-
-  // clang-format off
-  unsigned char packet_version32[] = {
-      // public flags (8 byte connection_id)
       static_cast<unsigned char>(
           framer_.version() > QUIC_VERSION_32 ? 0x38 : 0x3C),
       // connection_id
       0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
       // packet number
       0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
       // private flags (entropy)
       0x01,
 
       // frame type (ack frame)
@@ skipping 57 matching lines @@
 
       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
       0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
   };
   // clang-format on
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
-  if (framer_.version() <= QUIC_VERSION_31) {
-    test::CompareCharArraysWithHexError("constructed packet", data->data(),
-                                        data->length(), AsChars(packet),
-                                        arraysize(packet));
-  } else {
-    test::CompareCharArraysWithHexError(
-        "constructed packet", data->data(), data->length(),
-        AsChars(packet_version32), arraysize(packet_version32));
-  }
+  test::CompareCharArraysWithHexError(
+      "constructed packet", data->data(), data->length(),
+      AsChars(packet), arraysize(packet));
 }
 
 TEST_P(QuicFramerTest, BuildTruncatedAckFrameSmallPacket) {
   if (framer_.version() > QUIC_VERSION_33) {
     return;
   }
 
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
@@ skipping 12 matching lines @@
   for (size_t i = 1; i < 2 * 300; i += 2) {
     ack_frame.packets.Add(i);
   }
 
   QuicFrames frames;
   frames.push_back(QuicFrame(&ack_frame));
 
   // clang-format off
   unsigned char packet[] = {
       // public flags (8 byte connection_id)
-     0x3C,
-      // connection_id
-      0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
-      // packet number
-      0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
-      // private flags (entropy)
-      0x01,
-
-      // frame type (ack frame)
-      // (has nacks, is truncated, 2 byte largest observed, 1 byte delta)
-      0x74,
-      // entropy hash of all received packets, set to 1 by TestEntropyCalculator
-      // since ack is truncated.
-      0x01,
-      // 2-byte largest observed packet number.
-      // Expected to be 12 (0x0C), since only 6 nack ranges can fit.
-      0x0C, 0x00,
-      // Zero delta time.
-      0x00, 0x00,
-      // num missing packet ranges (limited to 6 by packet size of 37).
-      0x06,
-      // {missing packet delta, further missing packets in range}
-      // 6 nack ranges
-      0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
-      // 0 revived packets.
-      0x00,
-  };
-  // clang-format on
-
-  // clang-format off
-  unsigned char packet_version32[] = {
-      // public flags (8 byte connection_id)
       static_cast<unsigned char>(
           framer_.version() > QUIC_VERSION_32 ? 0x38 : 0x3C),
       // connection_id
       0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
       // packet number
       0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
       // private flags (entropy)
       0x01,
 
       // frame type (ack frame)
       // (has nacks, is truncated, 2 byte largest observed, 1 byte delta)
       0x74,
       // entropy hash of all received packets, set to 1 by TestEntropyCalculator
       // since ack is truncated.
       0x01,
       // 2-byte largest observed packet number.
       // Expected to be 12 (0x0C), since only 6 nack ranges can fit.
       0x0C, 0x00,
       // Zero delta time.
       0x00, 0x00,
       // num missing packet ranges (limited to 6 by packet size of 37).
       0x06,
       // {missing packet delta, further missing packets in range}
       // 6 nack ranges
       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
   };
   // clang-format on
 
-  if (framer_.version() <= QUIC_VERSION_31) {
-    std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames, 37u));
-    ASSERT_TRUE(data != nullptr);
-    // Expect 1 byte unused since at least 2 bytes are needed to fit more nacks.
-    EXPECT_EQ(36u, data->length());
-    test::CompareCharArraysWithHexError("constructed packet", data->data(),
-                                        data->length(), AsChars(packet),
-                                        arraysize(packet));
-  } else {
-    std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames, 36u));
-    ASSERT_TRUE(data != nullptr);
-    // Expect 1 byte unused since at least 2 bytes are needed to fit more nacks.
-    EXPECT_EQ(35u, data->length());
-    test::CompareCharArraysWithHexError(
-        "constructed packet", data->data(), data->length(),
-        AsChars(packet_version32), arraysize(packet_version32));
-  }
+  std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames, 36u));
+  ASSERT_TRUE(data != nullptr);
+  // Expect 1 byte unused since at least 2 bytes are needed to fit more nacks.
+  EXPECT_EQ(35u, data->length());
+  test::CompareCharArraysWithHexError(
+     "constructed packet", data->data(), data->length(),
+      AsChars(packet), arraysize(packet));
 }
 
 TEST_P(QuicFramerTest, BuildNewAckFramePacketOneAckBlock) {
   if (framer_.version() <= QUIC_VERSION_33) {
     return;
   }
 
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
@@ skipping 1699 matching lines @@
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
   // clang-format on
 
   QuicFramerFuzzFunc(packet, arraysize(packet));
 }
 
 }  // namespace test
 }  // namespace net