diff --git a/quic/core/quic_buffered_packet_store_test.cc b/quic/core/quic_buffered_packet_store_test.cc
index a00f213..dbf6c16 100644
--- a/quic/core/quic_buffered_packet_store_test.cc
+++ b/quic/core/quic_buffered_packet_store_test.cc
@@ -55,7 +55,7 @@
         packet_time_(QuicTime::Zero() + QuicTime::Delta::FromMicroseconds(42)),
         packet_(packet_content_.data(), packet_content_.size(), packet_time_),
         invalid_version_(UnsupportedQuicVersion()),
-        valid_version_(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_44) {}
+        valid_version_(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_46) {}
 
  protected:
   QuicBufferedPacketStoreVisitor visitor_;
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index fe4fe40..d0e5092 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -932,10 +932,9 @@
 TEST_F(QuicDispatcherTest, SupportedTransportVersionsChangeInFlight) {
   SetQuicRestartFlag(quic_dispatcher_hands_chlo_extractor_one_version, true);
   SetQuicReloadableFlag(quic_use_parse_public_header, true);
-  static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 7u,
+  static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
                 "Supported versions out of sync");
   SetQuicReloadableFlag(quic_disable_version_39, false);
-  SetQuicReloadableFlag(quic_disable_version_44, false);
   SetQuicReloadableFlag(quic_enable_version_47, true);
   SetQuicReloadableFlag(quic_enable_version_48_2, true);
   SetQuicReloadableFlag(quic_enable_version_99, true);
@@ -966,16 +965,6 @@
   VerifyVersionSupported(
       ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_47));
 
-  // Turn off version 44.
-  SetQuicReloadableFlag(quic_disable_version_44, true);
-  VerifyVersionNotSupported(
-      ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_44));
-
-  // Turn on version 44.
-  SetQuicReloadableFlag(quic_disable_version_44, false);
-  VerifyVersionSupported(
-      ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_44));
-
   // Turn off version 39.
   SetQuicReloadableFlag(quic_disable_version_39, true);
   VerifyVersionNotSupported(
@@ -988,7 +977,7 @@
 }
 
 TEST_F(QuicDispatcherTest, RejectDeprecatedVersionsWithVersionNegotiation) {
-  static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 7u,
+  static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
                 "Please add deprecated versions to this test");
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
   CreateTimeWaitListManager();
@@ -1002,6 +991,16 @@
               SendVersionNegotiationPacket(_, _, _, _, _, _, _, _))
       .Times(1);
   dispatcher_->ProcessPacket(server_address_, client_address, packet);
+
+  char packet44[kMinPacketSizeForVersionNegotiation] = {
+      0xFF, 'Q', '0', '4', '4', /*connection ID length byte*/ 0x50};
+  QuicReceivedPacket packet2(packet44, kMinPacketSizeForVersionNegotiation,
+                             QuicTime::Zero());
+  EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _)).Times(0);
+  EXPECT_CALL(*time_wait_list_manager_,
+              SendVersionNegotiationPacket(_, _, _, _, _, _, _, _))
+      .Times(1);
+  dispatcher_->ProcessPacket(server_address_, client_address, packet2);
 }
 
 TEST_F(QuicDispatcherTest, VersionNegotiationProbeOld) {
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 08593da..ffab835 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -191,66 +191,25 @@
 }
 
 uint8_t PacketNumberLengthToOnWireValue(
-    QuicTransportVersion version,
     QuicPacketNumberLength packet_number_length) {
-  if (version > QUIC_VERSION_44) {
-    return packet_number_length - 1;
-  }
-  switch (packet_number_length) {
-    case PACKET_1BYTE_PACKET_NUMBER:
-      return 0;
-    case PACKET_2BYTE_PACKET_NUMBER:
-      return 1;
-    case PACKET_4BYTE_PACKET_NUMBER:
-      return 2;
-    default:
-      QUIC_BUG << "Invalid packet number length.";
-      return 0;
-  }
+  return packet_number_length - 1;
 }
 
-bool GetShortHeaderPacketNumberLength(
-    QuicTransportVersion version,
-    uint8_t type,
-    bool infer_packet_header_type_from_version,
-    QuicPacketNumberLength* packet_number_length) {
+QuicPacketNumberLength GetShortHeaderPacketNumberLength(uint8_t type) {
   DCHECK(!(type & FLAGS_LONG_HEADER));
-  const bool two_bits_packet_number_length =
-      infer_packet_header_type_from_version ? version > QUIC_VERSION_44
-                                            : (type & FLAGS_FIXED_BIT);
-  if (two_bits_packet_number_length) {
-    *packet_number_length =
-        static_cast<QuicPacketNumberLength>((type & 0x03) + 1);
-    return true;
-  }
-  switch (type & 0x07) {
-    case 0:
-      *packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
-      break;
-    case 1:
-      *packet_number_length = PACKET_2BYTE_PACKET_NUMBER;
-      break;
-    case 2:
-      *packet_number_length = PACKET_4BYTE_PACKET_NUMBER;
-      break;
-    default:
-      *packet_number_length = PACKET_6BYTE_PACKET_NUMBER;
-      return false;
-  }
-  return true;
+  return static_cast<QuicPacketNumberLength>((type & 0x03) + 1);
 }
 
-uint8_t LongHeaderTypeToOnWireValue(QuicTransportVersion version,
-                                    QuicLongHeaderType type) {
+uint8_t LongHeaderTypeToOnWireValue(QuicLongHeaderType type) {
   switch (type) {
     case INITIAL:
-      return version > QUIC_VERSION_44 ? 0 : 0x7F;
+      return 0;
     case ZERO_RTT_PROTECTED:
-      return version > QUIC_VERSION_44 ? 1 << 4 : 0x7C;
+      return 1 << 4;
     case HANDSHAKE:
-      return version > QUIC_VERSION_44 ? 2 << 4 : 0x7D;
+      return 2 << 4;
     case RETRY:
-      return version > QUIC_VERSION_44 ? 3 << 4 : 0x7E;
+      return 3 << 4;
     case VERSION_NEGOTIATION:
       return 0xF0;  // Value does not matter
     default:
@@ -259,61 +218,31 @@
   }
 }
 
-bool GetLongHeaderType(QuicTransportVersion version,
-                       uint8_t type,
-                       QuicLongHeaderType* long_header_type) {
-  DCHECK((type & FLAGS_LONG_HEADER) && version != QUIC_VERSION_UNSUPPORTED);
-  if (version > QUIC_VERSION_44) {
-    switch ((type & 0x30) >> 4) {
-      case 0:
-        *long_header_type = INITIAL;
-        break;
-      case 1:
-        *long_header_type = ZERO_RTT_PROTECTED;
-        break;
-      case 2:
-        *long_header_type = HANDSHAKE;
-        break;
-      case 3:
-        *long_header_type = RETRY;
-        break;
-      default:
-        QUIC_BUG << "Unreachable statement";
-        *long_header_type = INVALID_PACKET_TYPE;
-        return false;
-    }
-    return true;
-  }
-
-  switch (type & 0x7F) {
-    case 0x7F:
+bool GetLongHeaderType(uint8_t type, QuicLongHeaderType* long_header_type) {
+  DCHECK((type & FLAGS_LONG_HEADER));
+  switch ((type & 0x30) >> 4) {
+    case 0:
       *long_header_type = INITIAL;
       break;
-    case 0x7C:
+    case 1:
       *long_header_type = ZERO_RTT_PROTECTED;
       break;
-    case 0x7D:
+    case 2:
       *long_header_type = HANDSHAKE;
       break;
-    case 0x7E:
+    case 3:
       *long_header_type = RETRY;
       break;
     default:
-      // Invalid packet header type. Whether a packet is version negotiation is
-      // determined by the version field.
+      QUIC_BUG << "Unreachable statement";
       *long_header_type = INVALID_PACKET_TYPE;
       return false;
   }
   return true;
 }
 
-QuicPacketNumberLength GetLongHeaderPacketNumberLength(
-    QuicTransportVersion version,
-    uint8_t type) {
-  if (version > QUIC_VERSION_44) {
-    return static_cast<QuicPacketNumberLength>((type & 0x03) + 1);
-  }
-  return PACKET_4BYTE_PACKET_NUMBER;
+QuicPacketNumberLength GetLongHeaderPacketNumberLength(uint8_t type) {
+  return static_cast<QuicPacketNumberLength>((type & 0x03) + 1);
 }
 
 // Used to get packet number space before packet gets decrypted.
@@ -1390,8 +1319,7 @@
   type |= FLAGS_FIXED_BIT;
   type |= FLAGS_SHORT_HEADER_RESERVED_1;
   type |= FLAGS_SHORT_HEADER_RESERVED_2;
-  type |= PacketNumberLengthToOnWireValue(QUIC_VERSION_UNSUPPORTED,
-                                          PACKET_1BYTE_PACKET_NUMBER);
+  type |= PacketNumberLengthToOnWireValue(PACKET_1BYTE_PACKET_NUMBER);
 
   // Append type byte.
   if (!writer.WriteUInt8(type)) {
@@ -2193,34 +2121,15 @@
 bool QuicFramer::AppendIetfHeaderTypeByte(const QuicPacketHeader& header,
                                           QuicDataWriter* writer) {
   uint8_t type = 0;
-  if (transport_version() > QUIC_VERSION_44) {
-    if (header.version_flag) {
-      type = static_cast<uint8_t>(
-          FLAGS_LONG_HEADER | FLAGS_FIXED_BIT |
-          LongHeaderTypeToOnWireValue(transport_version(),
-                                      header.long_packet_type) |
-          PacketNumberLengthToOnWireValue(transport_version(),
-                                          header.packet_number_length));
-    } else {
-      type = static_cast<uint8_t>(
-          FLAGS_FIXED_BIT |
-          PacketNumberLengthToOnWireValue(transport_version(),
-                                          header.packet_number_length));
-    }
-    return writer->WriteUInt8(type);
-  }
-
   if (header.version_flag) {
     type = static_cast<uint8_t>(
-        FLAGS_LONG_HEADER | LongHeaderTypeToOnWireValue(
-                                transport_version(), header.long_packet_type));
-    DCHECK_EQ(PACKET_4BYTE_PACKET_NUMBER, header.packet_number_length);
+        FLAGS_LONG_HEADER | FLAGS_FIXED_BIT |
+        LongHeaderTypeToOnWireValue(header.long_packet_type) |
+        PacketNumberLengthToOnWireValue(header.packet_number_length));
   } else {
-    type |= FLAGS_SHORT_HEADER_RESERVED_1;
-    type |= FLAGS_SHORT_HEADER_RESERVED_2;
-    DCHECK_GE(PACKET_4BYTE_PACKET_NUMBER, header.packet_number_length);
-    type |= PacketNumberLengthToOnWireValue(transport_version(),
-                                            header.packet_number_length);
+    type = static_cast<uint8_t>(
+        FLAGS_FIXED_BIT |
+        PacketNumberLengthToOnWireValue(header.packet_number_length));
   }
   return writer->WriteUInt8(type);
 }
@@ -2614,13 +2523,11 @@
     } else {
       header->version = ParseQuicVersionLabel(version_label);
       if (header->version.transport_version != QUIC_VERSION_UNSUPPORTED) {
-        if (header->version.transport_version > QUIC_VERSION_44 &&
-            !(type & FLAGS_FIXED_BIT)) {
+        if (!(type & FLAGS_FIXED_BIT)) {
           set_detailed_error("Fixed bit is 0 in long header.");
           return false;
         }
-        if (!GetLongHeaderType(header->version.transport_version, type,
-                               &header->long_packet_type)) {
+        if (!GetLongHeaderType(type, &header->long_packet_type)) {
           set_detailed_error("Illegal long header type value.");
           return false;
         }
@@ -2634,8 +2541,7 @@
             return false;
           }
         } else if (!header->version.HasHeaderProtection()) {
-          header->packet_number_length = GetLongHeaderPacketNumberLength(
-              header->version.transport_version, type);
+          header->packet_number_length = GetLongHeaderPacketNumberLength(type);
         }
       }
     }
@@ -2657,17 +2563,12 @@
           ? CONNECTION_ID_PRESENT
           : CONNECTION_ID_ABSENT;
   header->source_connection_id_included = CONNECTION_ID_ABSENT;
-  if (infer_packet_header_type_from_version_ &&
-      transport_version() > QUIC_VERSION_44 && !(type & FLAGS_FIXED_BIT)) {
+  if (!(type & FLAGS_FIXED_BIT)) {
     set_detailed_error("Fixed bit is 0 in short header.");
     return false;
   }
-  if (!header->version.HasHeaderProtection() &&
-      !GetShortHeaderPacketNumberLength(transport_version(), type,
-                                        infer_packet_header_type_from_version_,
-                                        &header->packet_number_length)) {
-    set_detailed_error("Illegal short header type value.");
-    return false;
+  if (!header->version.HasHeaderProtection()) {
+    header->packet_number_length = GetShortHeaderPacketNumberLength(type);
   }
   QUIC_DVLOG(1) << "packet_number_length = " << header->packet_number_length;
   return true;
@@ -2790,24 +2691,19 @@
     }
 
     if (header->version_flag &&
-        header->version.transport_version > QUIC_VERSION_44 &&
+        header->long_packet_type != VERSION_NEGOTIATION &&
         !(header->type_byte & FLAGS_FIXED_BIT)) {
       set_detailed_error("Fixed bit is 0 in long header.");
       return false;
     }
-    if (!header->version_flag && version_.transport_version > QUIC_VERSION_44 &&
-        !(header->type_byte & FLAGS_FIXED_BIT)) {
+    if (!header->version_flag && !(header->type_byte & FLAGS_FIXED_BIT)) {
       set_detailed_error("Fixed bit is 0 in short header.");
       return false;
     }
     if (!header->version_flag) {
-      if (!version_.HasHeaderProtection() &&
-          !GetShortHeaderPacketNumberLength(
-              transport_version(), header->type_byte,
-              infer_packet_header_type_from_version_,
-              &header->packet_number_length)) {
-        set_detailed_error("Failed to get short header packet number length.");
-        return false;
+      if (!version_.HasHeaderProtection()) {
+        header->packet_number_length =
+            GetShortHeaderPacketNumberLength(header->type_byte);
       }
       return true;
     }
@@ -2823,8 +2719,8 @@
       return true;
     }
     if (!header->version.HasHeaderProtection()) {
-      header->packet_number_length = GetLongHeaderPacketNumberLength(
-          header->version.transport_version, header->type_byte);
+      header->packet_number_length =
+          GetLongHeaderPacketNumberLength(header->type_byte);
     }
 
     return true;
@@ -2919,7 +2815,7 @@
       set_detailed_error("Unable to read frame type.");
       return RaiseError(QUIC_INVALID_FRAME_DATA);
     }
-    const uint8_t special_mask = transport_version() <= QUIC_VERSION_44
+    const uint8_t special_mask = transport_version() <= QUIC_VERSION_43
                                      ? kQuicFrameTypeBrokenMask
                                      : kQuicFrameTypeSpecialMask;
     if (frame_type & special_mask) {
@@ -3050,7 +2946,7 @@
 
       case STOP_WAITING_FRAME: {
         if (GetQuicReloadableFlag(quic_do_not_accept_stop_waiting) &&
-            version_.transport_version >= QUIC_VERSION_44) {
+            version_.transport_version > QUIC_VERSION_43) {
           QUIC_RELOADABLE_FLAG_COUNT(quic_do_not_accept_stop_waiting);
           set_detailed_error("STOP WAITING not supported in version 44+.");
           return RaiseError(QUIC_INVALID_STOP_WAITING_DATA);
@@ -4352,8 +4248,7 @@
   QuicLongHeaderType header_type;
   if (IsLongHeader(type_byte)) {
     bitmask = 0x0f;
-    if (!GetLongHeaderType(version_.transport_version, type_byte,
-                           &header_type)) {
+    if (!GetLongHeaderType(type_byte, &header_type)) {
       return false;
     }
   }
@@ -6641,8 +6536,7 @@
   }
 
   // Parse long packet type.
-  if (!GetLongHeaderType(parsed_version->transport_version, *first_byte,
-                         long_packet_type)) {
+  if (!GetLongHeaderType(*first_byte, long_packet_type)) {
     *detailed_error = "Unable to parse long packet type.";
     return QUIC_INVALID_PACKET_HEADER;
   }
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index 4eb20df..0200ed3 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -837,14 +837,6 @@
     // private flags
     0x00,
   };
-  unsigned char packet44[kMaxIncomingPacketSize + 1] = {
-    // type (short header 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x78, 0x56, 0x34, 0x12,
-  };
   unsigned char packet46[kMaxIncomingPacketSize + 1] = {
     // type (short header 4 byte packet number)
     0x43,
@@ -856,12 +848,9 @@
   // clang-format on
   unsigned char* p = packet;
   size_t p_size = QUIC_ARRAYSIZE(packet);
-  if (framer_.transport_version() > QUIC_VERSION_44) {
+  if (framer_.transport_version() > QUIC_VERSION_43) {
     p = packet46;
     p_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
 
   const size_t header_size = GetPacketHeaderSize(
@@ -952,23 +941,6 @@
 
 TEST_P(QuicFramerTest, LongPacketHeader) {
   // clang-format off
-  PacketFragments packet44 = {
-    // type (long header with packet type INITIAL)
-    {"Unable to read first byte.",
-     {0xFF}},
-    // version tag
-    {"Unable to read protocol version.",
-     {QUIC_VERSION_BYTES}},
-    // connection_id length
-    {"Unable to read ConnectionId length.",
-     {0x50}},
-    // connection_id
-    {"Unable to read destination connection ID.",
-     {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-    // packet number
-    {"Unable to read packet number.",
-     {0x12, 0x34, 0x56, 0x78}},
-  };
   PacketFragments packet46 = {
     // type (long header with packet type INITIAL)
     {"Unable to read first byte.",
@@ -993,10 +965,8 @@
     return;
   }
 
-  PacketFragments& fragments =
-      framer_.transport_version() > QUIC_VERSION_44 ? packet46 : packet44;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
-      AssemblePacketFromFragments(fragments));
+      AssemblePacketFromFragments(packet46));
 
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
@@ -1007,9 +977,7 @@
   EXPECT_TRUE(visitor_.header_->version_flag);
   EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
 
-  CheckFramingBoundaries(
-      framer_.transport_version() > QUIC_VERSION_44 ? packet46 : packet44,
-      QUIC_INVALID_PACKET_HEADER);
+  CheckFramingBoundaries(packet46, QUIC_INVALID_PACKET_HEADER);
 
   PacketHeaderFormat format;
   bool version_flag;
@@ -1048,13 +1016,11 @@
   }
   SetQuicReloadableFlag(quic_use_parse_public_header, false);
   SetDecrypterLevel(ENCRYPTION_ZERO_RTT);
-  const unsigned char type_byte =
-      framer_.transport_version() == QUIC_VERSION_44 ? 0xFC : 0xD3;
   // clang-format off
   unsigned char packet[] = {
     // public flags (long header with packet type ZERO_RTT_PROTECTED and
     // 4-byte packet number)
-    type_byte,
+    0xD3,
     // version
     QUIC_VERSION_BYTES,
     // connection ID lengths
@@ -1104,8 +1070,6 @@
 }
 
 TEST_P(QuicFramerTest, ParsePublicHeader) {
-  const unsigned char type_byte =
-      framer_.transport_version() == QUIC_VERSION_44 ? 0xFD : 0xE3;
   // clang-format off
   unsigned char packet[] = {
     // public flags (version included, 8-byte connection ID,
@@ -1120,22 +1084,22 @@
     // padding frame
     0x00,
   };
-  unsigned char packet44[] = {
-    // public flags (long header with packet type HANDSHAKE and
-    // 4-byte packet number)
-    type_byte,
-    // version
-    QUIC_VERSION_BYTES,
-    // connection ID lengths
-    0x50,
-    // destination connection ID
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // long header packet length
-    0x05,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-    // padding frame
-    0x00,
+  unsigned char packet46[] = {
+      // public flags (long header with packet type HANDSHAKE and
+      // 4-byte packet number)
+      0xE3,
+      // version
+      QUIC_VERSION_BYTES,
+      // connection ID lengths
+      0x50,
+      // destination connection ID
+      0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
+      // long header packet length
+      0x05,
+      // packet number
+      0x12, 0x34, 0x56, 0x78,
+      // padding frame
+      0x00,
   };
   unsigned char packet99[] = {
     // public flags (long header with packet type HANDSHAKE and
@@ -1162,9 +1126,9 @@
   if (framer_.transport_version() == QUIC_VERSION_99) {
     p = packet99;
     p_length = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() >= QUIC_VERSION_44) {
-    p = packet44;
-    p_length = QUIC_ARRAYSIZE(packet44);
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+    p = packet46;
+    p_length = QUIC_ARRAYSIZE(packet46);
   }
 
   uint8_t first_byte = 0x33;
@@ -1291,16 +1255,6 @@
        {0x12, 0x34, 0x56, 0x78}},
   };
 
-  PacketFragments packet44 = {
-        // type (short header, 4 byte packet number)
-        {"Unable to read first byte.",
-         {0x32}},
-        // connection_id
-        // packet number
-        {"Unable to read packet number.",
-         {0x12, 0x34, 0x56, 0x78}},
-   };
-
   PacketFragments packet46 = {
         // type (short header, 4 byte packet number)
         {"Unable to read first byte.",
@@ -1325,10 +1279,8 @@
   PacketFragments& fragments =
       framer_.version().HasHeaderProtection()
           ? packet_hp
-          : framer_.transport_version() > QUIC_VERSION_44
-                ? packet46
-                : (framer_.transport_version() > QUIC_VERSION_43 ? packet44
-                                                                 : packet);
+          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
+                                                            : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
@@ -1360,24 +1312,6 @@
        {0x12, 0x34, 0x56, 0x78}},
   };
 
-  PacketFragments packet44 = {
-      // type (long header with packet type ZERO_RTT_PROTECTED)
-      {"Unable to read first byte.",
-       {0xFC}},
-      // version tag
-      {"Unable to read protocol version.",
-       {QUIC_VERSION_BYTES}},
-      // connection_id length
-      {"Unable to read ConnectionId length.",
-       {0x50}},
-      // connection_id
-      {"Unable to read destination connection ID.",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // packet number
-      {"Unable to read packet number.",
-       {0x12, 0x34, 0x56, 0x78}},
-  };
-
   PacketFragments packet46 = {
       // type (long header with packet type ZERO_RTT_PROTECTED and 4 bytes
       // packet number)
@@ -1426,10 +1360,8 @@
   PacketFragments& fragments =
       framer_.transport_version() == QUIC_VERSION_99
           ? packet99
-          : framer_.transport_version() > QUIC_VERSION_44
-                ? packet46
-                : (framer_.transport_version() > QUIC_VERSION_43 ? packet44
-                                                                 : packet);
+          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
+                                                            : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
@@ -1462,18 +1394,6 @@
        {0x12, 0x34, 0x56, 0x78}},
   };
 
-  PacketFragments packet44 = {
-      // type (short header, 4 byte packet number)
-      {"Unable to read first byte.",
-       {0x32}},
-      // connection_id
-      {"Unable to read destination connection ID.",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // packet number
-      {"Unable to read packet number.",
-       {0x12, 0x34, 0x56, 0x78}},
-  };
-
   PacketFragments packet46 = {
       // type (short header, 4 byte packet number)
       {"Unable to read first byte.",
@@ -1502,10 +1422,8 @@
   PacketFragments& fragments =
       framer_.version().HasHeaderProtection()
           ? packet_hp
-          : framer_.transport_version() > QUIC_VERSION_44
-                ? packet46
-                : (framer_.transport_version() > QUIC_VERSION_43 ? packet44
-                                                                 : packet);
+          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
+                                                            : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
@@ -1537,18 +1455,6 @@
        {0x56, 0x78}},
   };
 
-  PacketFragments packet44 = {
-      // type (short header, 2 byte packet number)
-      {"Unable to read first byte.",
-       {0x31}},
-      // connection_id
-      {"Unable to read destination connection ID.",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // packet number
-      {"Unable to read packet number.",
-       {0x56, 0x78}},
-  };
-
   PacketFragments packet46 = {
       // type (short header, 2 byte packet number)
       {"Unable to read first byte.",
@@ -1579,10 +1485,8 @@
   PacketFragments& fragments =
       framer_.version().HasHeaderProtection()
           ? packet_hp
-          : (framer_.transport_version() > QUIC_VERSION_44
-                 ? packet46
-                 : (framer_.transport_version() > QUIC_VERSION_43 ? packet44
-                                                                  : packet));
+          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
+                                                            : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   if (framer_.version().HasHeaderProtection()) {
@@ -1620,18 +1524,6 @@
        {0x78}},
   };
 
-  PacketFragments packet44 = {
-      // type (8 byte connection_id and 1 byte packet number)
-      {"Unable to read first byte.",
-       {0x30}},
-      // connection_id
-      {"Unable to read destination connection ID.",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // packet number
-      {"Unable to read packet number.",
-       {0x78}},
-  };
-
   PacketFragments packet46 = {
       // type (8 byte connection_id and 1 byte packet number)
       {"Unable to read first byte.",
@@ -1663,10 +1555,8 @@
   PacketFragments& fragments =
       framer_.version().HasHeaderProtection()
           ? packet_hp
-          : (framer_.transport_version() > QUIC_VERSION_44
-                 ? packet46
-                 : (framer_.transport_version() > QUIC_VERSION_43 ? packet44
-                                                                  : packet));
+          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
+                                                            : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   if (framer_.version().HasHeaderProtection()) {
@@ -1775,28 +1665,6 @@
     0x00, 0x00, 0x00, 0x00
   };
 
-  unsigned char packet44[] = {
-    // type: Long header with packet type ZERO_RTT_PROTECTED
-    0xFC,
-    // version tag
-    QUIC_VERSION_BYTES,
-    // connection_id length
-    0x05,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-    // nonce
-    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-    0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
-    0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
-
-    // frame type (padding)
-    0x00,
-    0x00, 0x00, 0x00, 0x00
-  };
-
   unsigned char packet46[] = {
     // type: Long header with packet type ZERO_RTT_PROTECTED and 1 byte packet
     // number.
@@ -1857,12 +1725,9 @@
   if (framer_.transport_version() == QUIC_VERSION_99) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
     p_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -1893,24 +1758,7 @@
     0x00, 0x00, 0x00, 0x00
   };
 
-  unsigned char packet44[] = {
-    // type (long header with packet type ZERO_RTT_PROTECTED)
-    0xFC,
-    // version tag
-    'Q', '0', '0', '0',
-    // connection_id length
-    0x50,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (padding frame)
-    0x00,
-    0x00, 0x00, 0x00, 0x00
-  };
-
-  unsigned char packet45[] = {
+  unsigned char packet46[] = {
     // type (long header, ZERO_RTT_PROTECTED, 4-byte packet number)
     0xD3,
     // version tag
@@ -1952,12 +1800,9 @@
   if (framer_.transport_version() >= QUIC_VERSION_99) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
-    p = packet45;
-    p_size = QUIC_ARRAYSIZE(packet45);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+    p = packet46;
+    p_size = QUIC_ARRAYSIZE(packet46);
   }
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -1997,33 +1842,6 @@
     0x00, 0x00,
   };
 
-  unsigned char packet44[] = {
-    // type (short header, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // paddings
-    0x00, 0x00,
-    // frame type (stream frame with fin)
-    0xFF,
-    // stream id
-    0x01, 0x02, 0x03, 0x04,
-    // offset
-    0x3A, 0x98, 0xFE, 0xDC,
-    0x32, 0x10, 0x76, 0x54,
-    // data length
-    0x00, 0x0c,
-    // data
-    'h',  'e',  'l',  'l',
-    'o',  ' ',  'w',  'o',
-    'r',  'l',  'd',  '!',
-    // paddings
-    0x00, 0x00,
-  };
-
   unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
@@ -2085,12 +1903,9 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
     p_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -2145,36 +1960,6 @@
          'r',  'l',  'd',  '!'}},
   };
 
-  PacketFragments packet44 = {
-      // type (short header, 4 byte packet number)
-      {"",
-       {0x32}},
-      // connection_id
-      {"",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // packet number
-      {"",
-       {0x12, 0x34, 0x56, 0x78}},
-      // frame type (stream frame with fin)
-      {"",
-       {0xFF}},
-      // stream id
-      {"Unable to read stream_id.",
-       {0x01, 0x02, 0x03, 0x04}},
-      // offset
-      {"Unable to read offset.",
-       {0x3A, 0x98, 0xFE, 0xDC,
-        0x32, 0x10, 0x76, 0x54}},
-      {"Unable to read frame data.",
-       {
-         // data length
-         0x00, 0x0c,
-         // data
-         'h',  'e',  'l',  'l',
-         'o',  ' ',  'w',  'o',
-         'r',  'l',  'd',  '!'}},
-  };
-
   PacketFragments packet46 = {
       // type (short header, 4 byte packet number)
       {"",
@@ -2239,10 +2024,8 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() > QUIC_VERSION_44
-                 ? packet46
-                 : (framer_.transport_version() > QUIC_VERSION_43 ? packet44
-                                                                  : packet));
+          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
+                                                            : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -2349,21 +2132,6 @@
         0x00,
     };
 
-  unsigned char packet44[] = {
-        // type (long header, ZERO_RTT_PROTECTED, 4-byte packet number)
-        0xFC,
-        // version tag
-        QUIC_VERSION_BYTES,
-        // connection_id length
-        0x05,
-        // connection_id
-        0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
-        // packet number
-        0x12, 0x34, 0x56, 0x78,
-        // padding frame
-        0x00,
-    };
-
   unsigned char packet46[] = {
         // type (long header, ZERO_RTT_PROTECTED, 4-byte packet number)
         0xD3,
@@ -2407,16 +2175,13 @@
   } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
     p_length = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() >= QUIC_VERSION_44) {
-    p = packet44;
-    p_length = QUIC_ARRAYSIZE(packet44);
   }
   QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   if (framer_.version().HasHeaderProtection()) {
     EXPECT_EQ(QUIC_DECRYPTION_FAILURE, framer_.error());
     EXPECT_EQ("Unable to decrypt header protection.", framer_.detailed_error());
-  } else if (framer_.transport_version() >= QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     // Cannot read diversification nonce.
     EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, framer_.error());
     EXPECT_EQ("Unable to read nonce.", framer_.detailed_error());
@@ -2517,36 +2282,6 @@
          'r',  'l',  'd',  '!'}},
   };
 
-  PacketFragments packet44 = {
-      // type (short header, 4 byte packet number)
-      {"",
-       {0x32}},
-      // connection_id
-      {"",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // packet number
-      {"",
-       {0x12, 0x34, 0x56, 0x78}},
-       // frame type (stream frame with fin)
-       {"",
-        {0xFD}},
-       // stream id
-       {"Unable to read stream_id.",
-        {0x03, 0x04}},
-       // offset
-       {"Unable to read offset.",
-        {0x3A, 0x98, 0xFE, 0xDC,
-         0x32, 0x10, 0x76, 0x54}},
-       {"Unable to read frame data.",
-        {
-          // data length
-          0x00, 0x0c,
-          // data
-          'h',  'e',  'l',  'l',
-          'o',  ' ',  'w',  'o',
-          'r',  'l',  'd',  '!'}},
-  };
-
   PacketFragments packet46 = {
       // type (short header, 4 byte packet number)
       {"",
@@ -2611,10 +2346,8 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() > QUIC_VERSION_44
-                 ? packet46
-                 : (framer_.transport_version() > QUIC_VERSION_43 ? packet44
-                                                                  : packet));
+          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
+                                                            : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -2669,36 +2402,6 @@
          'r',  'l',  'd',  '!'}},
   };
 
-  PacketFragments packet44 = {
-      // type (short header, 4 byte packet number)
-      {"",
-       {0x32}},
-      // connection_id
-      {"",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // packet number
-      {"",
-       {0x12, 0x34, 0x56, 0x78}},
-      // frame type (stream frame with fin)
-      {"",
-       {0xFC}},
-      // stream id
-      {"Unable to read stream_id.",
-       {0x04}},
-      // offset
-      {"Unable to read offset.",
-       {0x3A, 0x98, 0xFE, 0xDC,
-        0x32, 0x10, 0x76, 0x54}},
-      {"Unable to read frame data.",
-       {
-         // data length
-         0x00, 0x0c,
-         // data
-         'h',  'e',  'l',  'l',
-         'o',  ' ',  'w',  'o',
-         'r',  'l',  'd',  '!'}},
-  };
-
   PacketFragments packet46 = {
       // type (short header, 4 byte packet number)
       {"",
@@ -2763,10 +2466,8 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() > QUIC_VERSION_44
-                 ? packet46
-                 : (framer_.transport_version() > QUIC_VERSION_43 ? packet44
-                                                                  : packet));
+          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
+                                                            : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -2830,42 +2531,6 @@
          'r',  'l',  'd',  '!'}},
   };
 
-  PacketFragments packet44 = {
-      // public flags (long header with packet type ZERO_RTT_PROTECTED)
-      {"",
-       {0xFC}},
-      // version tag
-      {"",
-       {QUIC_VERSION_BYTES}},
-      // connection_id length
-      {"",
-       {0x50}},
-      // connection_id
-      {"",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // packet number
-      {"",
-       {0x12, 0x34, 0x56, 0x78}},
-      // frame type (stream frame with fin)
-      {"",
-       {0xFE}},
-      // stream id
-      {"Unable to read stream_id.",
-       {0x02, 0x03, 0x04}},
-      // offset
-      {"Unable to read offset.",
-       {0x3A, 0x98, 0xFE, 0xDC,
-        0x32, 0x10, 0x76, 0x54}},
-      {"Unable to read frame data.",
-       {
-         // data length
-         0x00, 0x0c,
-         // data
-         'h',  'e',  'l',  'l',
-         'o',  ' ',  'w',  'o',
-         'r',  'l',  'd',  '!'}},
-  };
-
   PacketFragments packet46 = {
       // public flags (long header with packet type ZERO_RTT_PROTECTED and
       // 4-byte packet number)
@@ -2958,10 +2623,8 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() > QUIC_VERSION_44
-                 ? packet46
-                 : (framer_.transport_version() > QUIC_VERSION_43 ? packet44
-                                                                  : packet));
+          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
+                                                            : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -3015,29 +2678,6 @@
       'r',  'l',  'd',  '!',
   };
 
-  unsigned char packet44[] = {
-      // type (short header, 4 byte packet number)
-      0x32,
-      // connection_id
-      0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-      // packet number
-      0x12, 0x34, 0x56, 0x78,
-
-      // frame type (STREAM Frame with FIN, LEN, and OFFSET bits set)
-      0x10 | 0x01 | 0x02 | 0x04,
-      // stream id
-      kVarInt62FourBytes + 0x01, 0x02, 0x03, 0x04,
-      // offset
-      kVarInt62EightBytes + 0x3A, 0x98, 0xFE, 0xDC,
-      0x32, 0x10, 0x76, 0x54,
-      // data length
-      kVarInt62OneByte + 0x0c,
-      // data
-      'h',  'e',  'l',  'l',
-      'o',  ' ',  'w',  'o',
-      'r',  'l',  'd',  '!',
-  };
-
   unsigned char packet46[] = {
       // type (short header, 4 byte packet number)
       0x43,
@@ -3063,14 +2703,12 @@
   // clang-format on
 
   unsigned char* p = packet;
-  if (framer_.transport_version() > QUIC_VERSION_44) {
+  if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
   }
   QuicEncryptedPacket encrypted(AsChars(p),
                                 framer_.transport_version() > QUIC_VERSION_43
-                                    ? QUIC_ARRAYSIZE(packet44)
+                                    ? QUIC_ARRAYSIZE(packet46)
                                     : QUIC_ARRAYSIZE(packet),
                                 false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -3096,15 +2734,6 @@
     0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
   };
 
-  unsigned char packet44[] = {
-    // type (short header, 1 byte packet number)
-    0x30,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x01,
-  };
-
   unsigned char packet46[] = {
     // type (short header, 1 byte packet number)
     0x40,
@@ -3116,15 +2745,10 @@
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      framer_.transport_version() > QUIC_VERSION_44
-          ? AsChars(packet46)
-          : (framer_.transport_version() > QUIC_VERSION_43 ? AsChars(packet44)
-                                                           : AsChars(packet)),
-      framer_.transport_version() > QUIC_VERSION_44
-          ? QUIC_ARRAYSIZE(packet46)
-          : (framer_.transport_version() > QUIC_VERSION_43
-                 ? QUIC_ARRAYSIZE(packet44)
-                 : QUIC_ARRAYSIZE(packet)),
+      framer_.transport_version() >= QUIC_VERSION_46 ? AsChars(packet46)
+                                                     : AsChars(packet),
+      framer_.transport_version() >= QUIC_VERSION_46 ? QUIC_ARRAYSIZE(packet46)
+                                                     : QUIC_ARRAYSIZE(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
@@ -3164,34 +2788,6 @@
        {0x00}}
   };
 
-  PacketFragments packet44 = {
-      // type (short packet, 4 byte packet number)
-      {"",
-       {0x32}},
-      // connection_id
-      {"",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // packet number
-      {"",
-       {0x12, 0x34, 0x56, 0x78}},
-      // frame type (ack frame)
-      // (one ack block, 2 byte largest observed, 2 byte block length)
-      {"",
-       {0x45}},
-      // largest acked
-      {"Unable to read largest acked.",
-       {0x12, 0x34}},
-      // Zero delta time.
-      {"Unable to read ack delay time.",
-       {0x00, 0x00}},
-      // first ack block length.
-      {"Unable to read first ack block length.",
-       {0x12, 0x34}},
-      // num timestamps.
-      {"Unable to read num received packets.",
-       {0x00}}
-  };
-
   PacketFragments packet46 = {
       // type (short packet, 4 byte packet number)
       {"",
@@ -3259,10 +2855,8 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() > QUIC_VERSION_44
-                 ? packet46
-                 : (framer_.transport_version() > QUIC_VERSION_43 ? packet44
-                                                                  : packet));
+          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
+                                                            : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -3316,34 +2910,6 @@
        {0x00}}
   };
 
-  PacketFragments packet44 = {
-      // type (short header, 4 byte packet number)
-      {"",
-       {0x32}},
-      // connection_id
-      {"",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // packet number
-      {"",
-       {0x12, 0x34, 0x56, 0x78}},
-      // frame type (ack frame)
-      // (one ack block, 2 byte largest observed, 2 byte block length)
-      {"",
-       {0x45}},
-      // largest acked
-      {"Unable to read largest acked.",
-       {0x12, 0x34}},
-      // Zero delta time.
-      {"Unable to read ack delay time.",
-       {0x00, 0x00}},
-      // first ack block length.
-      {"Unable to read first ack block length.",
-       {0x88, 0x88}},
-      // num timestamps.
-      {"Underflow with first ack block length 34952 largest acked is 4660.",
-       {0x00}}
-  };
-
   PacketFragments packet46 = {
       // type (short header, 4 byte packet number)
       {"",
@@ -3403,10 +2969,8 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() > QUIC_VERSION_44
-                 ? packet46
-                 : (framer_.transport_version() > QUIC_VERSION_43 ? packet44
-                                                                  : packet));
+          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
+                                                            : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
@@ -3734,44 +3298,6 @@
         { 0x00 }},
   };
 
-  PacketFragments packet44 = {
-      // type (short header, 4 byte packet number)
-      {"",
-       { 0x32 }},
-      // connection_id
-      {"",
-       { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 }},
-      // packet number
-      {"",
-       { 0x12, 0x34, 0x56, 0x78 }},
-
-      // frame type (ack frame)
-      // (more than one ack block, 2 byte largest observed, 2 byte block length)
-      {"",
-       { 0x65 }},
-      // largest acked
-      {"Unable to read largest acked.",
-       { 0x12, 0x34 }},
-      // Zero delta time.
-      {"Unable to read ack delay time.",
-       { 0x00, 0x00 }},
-      // num ack blocks ranges.
-      {"Unable to read num of ack blocks.",
-       { 0x01 }},
-      // first ack block length.
-      {"Unable to read first ack block length.",
-       { 0x00, 0x00 }},
-      // gap to next block.
-      { "First block length is zero.",
-        { 0x01 }},
-      // ack block length.
-      { "First block length is zero.",
-        { 0x0e, 0xaf }},
-      // Number of timestamps.
-      { "First block length is zero.",
-        { 0x00 }},
-  };
-
   PacketFragments packet46 = {
       // type (short header, 4 byte packet number)
       {"",
@@ -3812,9 +3338,7 @@
 
   // clang-format on
   PacketFragments& fragments =
-      framer_.transport_version() > QUIC_VERSION_44
-          ? packet46
-          : (framer_.transport_version() > QUIC_VERSION_43 ? packet44 : packet);
+      framer_.transport_version() >= QUIC_VERSION_46 ? packet46 : packet;
 
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
@@ -3864,34 +3388,6 @@
        {0x00}}
   };
 
-  PacketFragments packet44 = {
-      // type (short header, 4 byte packet number)
-      {"",
-       {0x32}},
-      // connection_id
-      {"",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // packet number
-      {"",
-       {0x56, 0x78, 0x9A, 0xBC}},
-      // frame type (ack frame)
-      // (one ack block, 4 byte largest observed, 2 byte block length)
-      {"",
-       {0x49}},
-      // largest acked
-      {"Unable to read largest acked.",
-       {0x12, 0x34, 0x56, 0x78}},
-      // Zero delta time.
-      {"Unable to read ack delay time.",
-       {0x00, 0x00}},
-      // first ack block length.
-      {"Unable to read first ack block length.",
-       {0x12, 0x34}},
-      // num timestamps.
-      {"Unable to read num received packets.",
-       {0x00}}
-  };
-
   PacketFragments packet46 = {
       // type (short header, 4 byte packet number)
       {"",
@@ -3951,10 +3447,8 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() > QUIC_VERSION_44
-                 ? packet46
-                 : (framer_.transport_version() > QUIC_VERSION_43 ? packet44
-                                                                  : packet));
+          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
+                                                            : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -4047,74 +3541,6 @@
         { 0x32, 0x10 }},
   };
 
-  PacketFragments packet44 = {
-      // type (short header, 4 byte packet number)
-      {"",
-       { 0x32 }},
-      // connection_id
-      {"",
-       { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 }},
-      // packet number
-      {"",
-       { 0x12, 0x34, 0x56, 0x78 }},
-
-      // frame type (ack frame)
-      // (more than one ack block, 2 byte largest observed, 2 byte block length)
-      {"",
-       { 0x65 }},
-      // largest acked
-      {"Unable to read largest acked.",
-       { 0x12, 0x34 }},
-      // Zero delta time.
-      {"Unable to read ack delay time.",
-       { 0x00, 0x00 }},
-      // num ack blocks ranges.
-      {"Unable to read num of ack blocks.",
-       { 0x04 }},
-      // first ack block length.
-      {"Unable to read first ack block length.",
-       { 0x00, 0x01 }},
-      // gap to next block.
-      { "Unable to read gap to next ack block.",
-        { 0x01 }},
-      // ack block length.
-      { "Unable to ack block length.",
-        { 0x0e, 0xaf }},
-      // gap to next block.
-      { "Unable to read gap to next ack block.",
-        { 0xff }},
-      // ack block length.
-      { "Unable to ack block length.",
-        { 0x00, 0x00 }},
-      // gap to next block.
-      { "Unable to read gap to next ack block.",
-        { 0x91 }},
-      // ack block length.
-      { "Unable to ack block length.",
-        { 0x01, 0xea }},
-      // gap to next block.
-      { "Unable to read gap to next ack block.",
-        { 0x05 }},
-      // ack block length.
-      { "Unable to ack block length.",
-        { 0x00, 0x04 }},
-      // Number of timestamps.
-      { "Unable to read num received packets.",
-        { 0x02 }},
-      // Delta from largest observed.
-      { "Unable to read sequence delta in received packets.",
-        { 0x01 }},
-      // Delta time.
-      { "Unable to read time delta in received packets.",
-        { 0x76, 0x54, 0x32, 0x10 }},
-      // Delta from largest observed.
-      { "Unable to read sequence delta in received packets.",
-        { 0x02 }},
-      // Delta time.
-      { "Unable to read incremental time delta in received packets.",
-        { 0x32, 0x10 }},
-  };
-
   PacketFragments packet46 = {
       // type (short header, 4 byte packet number)
       {"",
@@ -4243,10 +3669,8 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() > QUIC_VERSION_44
-                 ? packet46
-                 : (framer_.transport_version() > QUIC_VERSION_43 ? packet44
-                                                                  : packet));
+          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
+                                                            : packet);
 
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
@@ -4302,31 +3726,6 @@
       0x10, 0x32, 0x54, 0x76,
   };
 
-  unsigned char packet44[] = {
-      // type (short header, 4 byte packet number)
-      0x32,
-      // connection_id
-      0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-      // packet number
-      0x12, 0x34, 0x56, 0x78,
-
-      // frame type (ack frame)
-      // (no ack blocks, 1 byte largest observed, 1 byte block length)
-      0x40,
-      // largest acked
-      0x01,
-      // Zero delta time.
-      0x00, 0x00,
-      // first ack block length.
-      0x01,
-      // num timestamps.
-      0x01,
-      // Delta from largest observed.
-      0x01,
-      // Delta time.
-      0x10, 0x32, 0x54, 0x76,
-  };
-
   unsigned char packet46[] = {
       // type (short header, 4 byte packet number)
       0x43,
@@ -4356,10 +3755,8 @@
     return;
   }
   QuicEncryptedPacket encrypted(
-      AsChars(framer_.transport_version() > QUIC_VERSION_44
-                  ? packet46
-                  : (framer_.transport_version() > QUIC_VERSION_43 ? packet44
-                                                                   : packet)),
+      AsChars(framer_.transport_version() >= QUIC_VERSION_46 ? packet46
+                                                             : packet),
       QUIC_ARRAYSIZE(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_TRUE(QuicTextUtils::StartsWith(
@@ -4398,35 +3795,6 @@
       0x10, 0x32,
   };
 
-  unsigned char packet44[] = {
-      // type (short header, 4 byte packet number)
-      0x32,
-      // connection_id
-      0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-      // packet number
-      0x12, 0x34, 0x56, 0x78,
-
-      // frame type (ack frame)
-      // (no ack blocks, 1 byte largest observed, 1 byte block length)
-      0x40,
-      // largest acked
-      0x03,
-      // Zero delta time.
-      0x00, 0x00,
-      // first ack block length.
-      0x03,
-      // num timestamps.
-      0x02,
-      // Delta from largest observed.
-      0x01,
-      // Delta time.
-      0x10, 0x32, 0x54, 0x76,
-      // Delta from largest observed.
-      0x03,
-      // Delta time.
-      0x10, 0x32,
-  };
-
   unsigned char packet46[] = {
       // type (short header, 4 byte packet number)
       0x43,
@@ -4460,10 +3828,8 @@
     return;
   }
   QuicEncryptedPacket encrypted(
-      AsChars(framer_.transport_version() > QUIC_VERSION_44
-                  ? packet46
-                  : (framer_.transport_version() > QUIC_VERSION_43 ? packet44
-                                                                   : packet)),
+      AsChars(framer_.transport_version() >= QUIC_VERSION_46 ? packet46
+                                                             : packet),
       QUIC_ARRAYSIZE(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_TRUE(QuicTextUtils::StartsWith(
@@ -4494,24 +3860,6 @@
         {0x00, 0x00, 0x00, 0x08}}
   };
 
-  PacketFragments packet44 = {
-      // type (short header, 4 byte packet number)
-      {"",
-       {0x32}},
-      // connection_id
-      {"",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // packet number
-      {"",
-       {0x12, 0x34, 0x56, 0x78}},
-      // frame type (stop waiting frame)
-      {"",
-       {0x06}},
-      // least packet number awaiting an ack, delta from packet number.
-      {"Unable to read least unacked delta.",
-        {0x00, 0x00, 0x00, 0x08}}
-  };
-
   PacketFragments packet46 = {
       // type (short header, 4 byte packet number)
       {"",
@@ -4532,14 +3880,12 @@
   // clang-format on
 
   PacketFragments& fragments =
-      framer_.transport_version() > QUIC_VERSION_44
-          ? packet46
-          : (framer_.transport_version() > QUIC_VERSION_43 ? packet44 : packet);
+      framer_.transport_version() >= QUIC_VERSION_46 ? packet46 : packet;
 
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   if (GetQuicReloadableFlag(quic_do_not_accept_stop_waiting) &&
-      version_.transport_version >= QUIC_VERSION_44) {
+      version_.transport_version >= QUIC_VERSION_46) {
     EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
     EXPECT_EQ(QUIC_INVALID_STOP_WAITING_DATA, framer_.error());
     EXPECT_EQ("STOP WAITING not supported in version 44+.",
@@ -4566,7 +3912,7 @@
 TEST_P(QuicFramerTest, InvalidNewStopWaitingFrame) {
   if (VersionHasIetfQuicFrames(version_.transport_version) ||
       (GetQuicReloadableFlag(quic_do_not_accept_stop_waiting) &&
-       version_.transport_version >= QUIC_VERSION_44)) {
+       version_.transport_version >= QUIC_VERSION_46)) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -4585,19 +3931,6 @@
     0x9A, 0xA8,
   };
 
-  unsigned char packet44[] = {
-    // type (short header, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-    // frame type (stop waiting frame)
-    0x06,
-    // least packet number awaiting an ack, delta from packet number.
-    0x57, 0x78, 0x9A, 0xA8,
-  };
-
   unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
@@ -4613,11 +3946,9 @@
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(framer_.transport_version() > QUIC_VERSION_44
-                  ? packet46
-                  : (framer_.transport_version() > QUIC_VERSION_43 ? packet44
-                                                                   : packet)),
-      framer_.transport_version() > QUIC_VERSION_43 ? QUIC_ARRAYSIZE(packet44)
+      AsChars(framer_.transport_version() >= QUIC_VERSION_46 ? packet46
+                                                             : packet),
+      framer_.transport_version() > QUIC_VERSION_43 ? QUIC_ARRAYSIZE(packet46)
                                                     : QUIC_ARRAYSIZE(packet),
       false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
@@ -4653,31 +3984,6 @@
        {0x00, 0x00, 0x00, 0x01}}
   };
 
-  PacketFragments packet44 = {
-      // type (short header, 4 byte packet number)
-      {"",
-       {0x32}},
-      // connection_id
-      {"",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // packet number
-      {"",
-       {0x12, 0x34, 0x56, 0x78}},
-      // frame type (rst stream frame)
-      {"",
-       {0x01}},
-      // stream id
-      {"Unable to read stream_id.",
-       {0x01, 0x02, 0x03, 0x04}},
-      // sent byte offset
-      {"Unable to read rst stream sent byte offset.",
-       {0x3A, 0x98, 0xFE, 0xDC,
-        0x32, 0x10, 0x76, 0x54}},
-      // error code
-      {"Unable to read rst stream error code.",
-       {0x00, 0x00, 0x00, 0x01}}
-  };
-
   PacketFragments packet46 = {
       // type (short header, 4 byte packet number)
       {"",
@@ -4731,10 +4037,8 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() > QUIC_VERSION_44
-                 ? packet46
-                 : (framer_.transport_version() > QUIC_VERSION_43 ? packet44
-                                                                  : packet));
+          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
+                                                            : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -4782,34 +4086,6 @@
       }
   };
 
-  PacketFragments packet44 = {
-      // type (short header, 4 byte packet number)
-      {"",
-       {0x32}},
-      // connection_id
-      {"",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // packet number
-      {"",
-       {0x12, 0x34, 0x56, 0x78}},
-      // frame type (connection close frame)
-      {"",
-       {0x02}},
-      // error code
-      {"Unable to read connection close error code.",
-       {0x00, 0x00, 0x00, 0x11}},
-      {"Unable to read connection close error details.",
-       {
-         // error details length
-         0x0, 0x0d,
-         // error details
-         'b',  'e',  'c',  'a',
-         'u',  's',  'e',  ' ',
-         'I',  ' ',  'c',  'a',
-         'n'}
-      }
-  };
-
   PacketFragments packet46 = {
       // type (short header, 4 byte packet number)
       {"",
@@ -4872,10 +4148,8 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() > QUIC_VERSION_44
-                 ? packet46
-                 : (framer_.transport_version() > QUIC_VERSION_43 ? packet44
-                                                                  : packet));
+          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
+                                                            : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -4944,35 +4218,6 @@
     }
   };
 
-    PacketFragments packet44 = {
-    // type (short header, 4 byte packet number)
-    {"",
-     {0x32}},
-    // connection_id
-    {"",
-     {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-    // packet number
-    {"",
-     {0x12, 0x34, 0x56, 0x78}},
-    // frame type (IETF Transport CONNECTION_CLOSE frame)
-    {"",
-     {0x02}},
-    // error code
-    {"Unable to read connection close error code.",
-     {0x00, 0x00, 0x00, 0x11}},
-    {"Unable to read connection close error details.",
-     {
-       // error details length
-       0x00, 0x13,
-       // error details
-      '1',  '7',  '7',  '6',
-      '7',  ':',  'b',  'e',
-      'c',  'a',  'u',  's',
-      'e',  ' ',  'I',  ' ',
-      'c',  'a',  'n'}
-    }
-  };
-
   PacketFragments packet46 = {
     // type (short header, 4 byte packet number)
     {"",
@@ -5037,10 +4282,8 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() > QUIC_VERSION_44
-                 ? packet46
-                 : (framer_.transport_version() > QUIC_VERSION_43 ? packet44
-                                                                  : packet));
+          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
+                                                            : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -5233,38 +4476,6 @@
       }
   };
 
-  PacketFragments packet44 = {
-      // type (short header, 4 byte packet number)
-      {"",
-       {0x32}},
-      // connection_id
-      {"",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // packet number
-      {"",
-       {0x12, 0x34, 0x56, 0x78}},
-      // frame type (go away frame)
-      {"",
-       {0x03}},
-      // error code
-      {"Unable to read go away error code.",
-       {0x00, 0x00, 0x00, 0x09}},
-      // stream id
-      {"Unable to read last good stream id.",
-       {0x01, 0x02, 0x03, 0x04}},
-      // stream id
-      {"Unable to read goaway reason.",
-       {
-         // error details length
-         0x0, 0x0d,
-         // error details
-         'b',  'e',  'c',  'a',
-         'u',  's',  'e',  ' ',
-         'I',  ' ',  'c',  'a',
-         'n'}
-      }
-  };
-
   PacketFragments packet46 = {
       // type (short header, 4 byte packet number)
       {"",
@@ -5299,9 +4510,7 @@
   // clang-format on
 
   PacketFragments& fragments =
-      framer_.transport_version() > QUIC_VERSION_44
-          ? packet46
-          : (framer_.transport_version() > QUIC_VERSION_43 ? packet44 : packet);
+      framer_.transport_version() >= QUIC_VERSION_46 ? packet46 : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -5349,28 +4558,6 @@
         0x32, 0x10, 0x76, 0x54}},
   };
 
-  PacketFragments packet44 = {
-      // type (short header, 4 byte packet number)
-      {"",
-       {0x32}},
-      // connection_id
-      {"",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // packet number
-      {"",
-       {0x12, 0x34, 0x56, 0x78}},
-      // frame type (window update frame)
-      {"",
-       {0x04}},
-      // stream id
-      {"Unable to read stream_id.",
-       {0x01, 0x02, 0x03, 0x04}},
-      // byte offset
-      {"Unable to read window byte_offset.",
-       {0x3A, 0x98, 0xFE, 0xDC,
-        0x32, 0x10, 0x76, 0x54}},
-  };
-
   PacketFragments packet46 = {
       // type (short header, 4 byte packet number)
       {"",
@@ -5396,9 +4583,7 @@
   // clang-format on
 
   PacketFragments& fragments =
-      framer_.transport_version() > QUIC_VERSION_44
-          ? packet46
-          : (framer_.transport_version() > QUIC_VERSION_43 ? packet44 : packet);
+      framer_.transport_version() >= QUIC_VERSION_46 ? packet46 : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -5526,24 +4711,6 @@
        {0x01, 0x02, 0x03, 0x04}},
   };
 
-  PacketFragments packet44 = {
-      // type (short header, 4 byte packet number)
-      {"",
-       {0x32}},
-      // connection_id
-      {"",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // packet number
-      {"",
-       {0x12, 0x34, 0x56, 0x78}},
-      // frame type (blocked frame)
-      {"",
-       {0x05}},
-      // stream id
-      {"Unable to read stream_id.",
-       {0x01, 0x02, 0x03, 0x04}},
-  };
-
   PacketFragments packet46 = {
       // type (short header, 4 byte packet number)
       {"",
@@ -5587,10 +4754,8 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() > QUIC_VERSION_44
-                 ? packet46
-                 : (framer_.transport_version() > QUIC_VERSION_43 ? packet44
-                                                                  : packet));
+          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
+                                                            : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -5630,18 +4795,6 @@
      0x07,
     };
 
-  unsigned char packet44[] = {
-     // type (short header, 4 byte packet number)
-     0x32,
-     // connection_id
-     0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-     // packet number
-     0x12, 0x34, 0x56, 0x78,
-
-     // frame type
-     0x07,
-    };
-
   unsigned char packet46[] = {
      // type (short header, 4 byte packet number)
      0x43,
@@ -5670,18 +4823,13 @@
   QuicEncryptedPacket encrypted(
       AsChars(VersionHasIetfQuicFrames(framer_.transport_version())
                   ? packet99
-                  : (framer_.transport_version() > QUIC_VERSION_44
-                         ? packet46
-                         : framer_.transport_version() > QUIC_VERSION_43
-                               ? packet44
-                               : packet)),
+                  : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
+                                                                    : packet)),
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? QUIC_ARRAYSIZE(packet99)
-          : (framer_.transport_version() > QUIC_VERSION_44
+          : (framer_.transport_version() >= QUIC_VERSION_46
                  ? QUIC_ARRAYSIZE(packet46)
-                 : framer_.transport_version() > QUIC_VERSION_43
-                       ? QUIC_ARRAYSIZE(packet44)
-                       : QUIC_ARRAYSIZE(packet)),
+                 : QUIC_ARRAYSIZE(packet)),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
@@ -5697,38 +4845,11 @@
 }
 
 TEST_P(QuicFramerTest, MessageFrame) {
-  if (framer_.transport_version() <= QUIC_VERSION_44) {
+  if (framer_.transport_version() <= QUIC_VERSION_43) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
-  PacketFragments packet45 = {
-       // type (short header, 4 byte packet number)
-       {"",
-        {0x32}},
-       // connection_id
-       {"",
-        {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-       // packet number
-       {"",
-        {0x12, 0x34, 0x56, 0x78}},
-       // message frame type.
-       {"",
-        { 0x21 }},
-       // message length
-       {"Unable to read message length",
-        {0x07}},
-       // message data
-       {"Unable to read message data",
-        {'m', 'e', 's', 's', 'a', 'g', 'e'}},
-        // message frame no length.
-        {"",
-         { 0x20 }},
-        // message data
-        {{},
-         {'m', 'e', 's', 's', 'a', 'g', 'e', '2'}},
-   };
-
   PacketFragments packet46 = {
        // type (short header, 4 byte packet number)
        {"",
@@ -5757,8 +4878,8 @@
    };
   // clang-format on
 
-  std::unique_ptr<QuicEncryptedPacket> encrypted(AssemblePacketFromFragments(
-      framer_.transport_version() > QUIC_VERSION_44 ? packet46 : packet45));
+  std::unique_ptr<QuicEncryptedPacket> encrypted(
+      AssemblePacketFromFragments(packet46));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
@@ -5771,9 +4892,7 @@
   EXPECT_EQ(7u, visitor_.message_frames_[0]->message_length);
   EXPECT_EQ(8u, visitor_.message_frames_[1]->message_length);
 
-  CheckFramingBoundaries(
-      framer_.transport_version() > QUIC_VERSION_44 ? packet46 : packet45,
-      QUIC_INVALID_MESSAGE_DATA);
+  CheckFramingBoundaries(packet46, QUIC_INVALID_MESSAGE_DATA);
 }
 
 TEST_P(QuicFramerTest, PublicResetPacketV33) {
@@ -6079,7 +5198,7 @@
         'Q', '2', '.', '0'}},
   };
 
-  PacketFragments packet44 = {
+  PacketFragments packet46 = {
       // type (long header)
       {"",
        {0x8F}},
@@ -6123,7 +5242,7 @@
   PacketFragments& fragments =
       framer_.transport_version() >= QUIC_VERSION_99
           ? packet99
-          : framer_.transport_version() > QUIC_VERSION_43 ? packet44 : packet;
+          : framer_.transport_version() > QUIC_VERSION_43 ? packet46 : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -6142,7 +5261,7 @@
 }
 
 TEST_P(QuicFramerTest, VersionNegotiationPacketServer) {
-  if (framer_.transport_version() < QUIC_VERSION_44) {
+  if (framer_.transport_version() <= QUIC_VERSION_43) {
     return;
   }
 
@@ -6352,19 +5471,6 @@
     0x00, 0x00, 0x00, 0x00
   };
 
-  unsigned char packet44[kMaxOutgoingPacketSize] = {
-    // type (short header, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (padding frame)
-    0x00,
-    0x00, 0x00, 0x00, 0x00
-  };
-
   unsigned char packet46[kMaxOutgoingPacketSize] = {
     // type (short header, 4 byte packet number)
     0x43,
@@ -6395,10 +5501,8 @@
   unsigned char* p = packet;
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
   }
 
   uint64_t header_size = GetPacketHeaderSize(
@@ -6413,7 +5517,7 @@
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p),
-      framer_.transport_version() > QUIC_VERSION_43 ? QUIC_ARRAYSIZE(packet44)
+      framer_.transport_version() > QUIC_VERSION_43 ? QUIC_ARRAYSIZE(packet46)
                                                     : QUIC_ARRAYSIZE(packet));
 }
 
@@ -6458,33 +5562,6 @@
     0x00, 0x00,
   };
 
-  unsigned char packet44[] = {
-    // type (short header, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // paddings
-    0x00, 0x00,
-    // frame type (stream frame with fin)
-    0xFF,
-    // stream id
-    0x01, 0x02, 0x03, 0x04,
-    // offset
-    0x3A, 0x98, 0xFE, 0xDC,
-    0x32, 0x10, 0x76, 0x54,
-    // data length
-    0x00, 0x0c,
-    // data
-    'h',  'e',  'l',  'l',
-    'o',  ' ',  'w',  'o',
-    'r',  'l',  'd',  '!',
-    // paddings
-    0x00, 0x00,
-  };
-
   unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
@@ -6548,12 +5625,9 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
     p_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
 
@@ -6586,19 +5660,6 @@
     0x00, 0x00, 0x00, 0x00
   };
 
-  unsigned char packet44[kMaxOutgoingPacketSize] = {
-    // type (short header, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (padding frame)
-    0x00,
-    0x00, 0x00, 0x00, 0x00
-  };
-
   unsigned char packet46[kMaxOutgoingPacketSize] = {
     // type (short header, 4 byte packet number)
     0x43,
@@ -6629,10 +5690,8 @@
   unsigned char* p = packet;
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
   }
 
   uint64_t header_size = GetPacketHeaderSize(
@@ -6647,7 +5706,7 @@
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p),
-      framer_.transport_version() > QUIC_VERSION_43 ? QUIC_ARRAYSIZE(packet44)
+      framer_.transport_version() > QUIC_VERSION_43 ? QUIC_ARRAYSIZE(packet46)
                                                     : QUIC_ARRAYSIZE(packet));
 }
 
@@ -6676,19 +5735,6 @@
     0x00, 0x00, 0x00, 0x00
   };
 
-  unsigned char packet44[kMaxOutgoingPacketSize] = {
-    // type (short header, 2 byte packet number)
-    0x31,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x56, 0x78,
-
-    // frame type (padding frame)
-    0x00,
-    0x00, 0x00, 0x00, 0x00
-  };
-
   unsigned char packet46[kMaxOutgoingPacketSize] = {
     // type (short header, 2 byte packet number)
     0x41,
@@ -6719,10 +5765,8 @@
   unsigned char* p = packet;
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
   }
 
   uint64_t header_size = GetPacketHeaderSize(
@@ -6737,7 +5781,7 @@
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p),
-      framer_.transport_version() > QUIC_VERSION_43 ? QUIC_ARRAYSIZE(packet44)
+      framer_.transport_version() > QUIC_VERSION_43 ? QUIC_ARRAYSIZE(packet46)
                                                     : QUIC_ARRAYSIZE(packet));
 }
 
@@ -6766,19 +5810,6 @@
     0x00, 0x00, 0x00, 0x00
   };
 
-  unsigned char packet44[kMaxOutgoingPacketSize] = {
-    // type (short header, 1 byte packet number)
-    0x30,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x78,
-
-    // frame type (padding frame)
-    0x00,
-    0x00, 0x00, 0x00, 0x00
-  };
-
   unsigned char packet46[kMaxOutgoingPacketSize] = {
     // type (short header, 1 byte packet number)
     0x40,
@@ -6809,10 +5840,8 @@
   unsigned char* p = packet;
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
   }
 
   uint64_t header_size = GetPacketHeaderSize(
@@ -6827,7 +5856,7 @@
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p),
-      framer_.transport_version() > QUIC_VERSION_43 ? QUIC_ARRAYSIZE(packet44)
+      framer_.transport_version() > QUIC_VERSION_43 ? QUIC_ARRAYSIZE(packet46)
                                                     : QUIC_ARRAYSIZE(packet));
 }
 
@@ -6869,27 +5898,6 @@
     'r',  'l',  'd',  '!',
   };
 
-  unsigned char packet44[] = {
-    // type (short header, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (stream frame with fin and no length)
-    0xDF,
-    // stream id
-    0x01, 0x02, 0x03, 0x04,
-    // offset
-    0x3A, 0x98, 0xFE, 0xDC,
-    0x32, 0x10, 0x76, 0x54,
-    // data
-    'h',  'e',  'l',  'l',
-    'o',  ' ',  'w',  'o',
-    'r',  'l',  'd',  '!',
-  };
-
   unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
@@ -6941,12 +5949,9 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
     p_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
   test::CompareCharArraysWithHexError("constructed packet", data->data(),
                                       data->length(), AsChars(p), p_size);
@@ -6990,28 +5995,6 @@
       'h',  'e',  'l',  'l',  'o',  ' ',  'w',  'o',  'r', 'l', 'd', '!',
   };
 
-  unsigned char packet44[] = {
-      // type (long header with packet type ZERO_RTT_PROTECTED)
-      0xFC,
-      // version tag
-      QUIC_VERSION_BYTES,
-      // connection_id length
-      0x50,
-      // connection_id
-      0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-      // packet number
-      0x12, 0x34, 0x56, 0x78,
-
-      // frame type (stream frame with fin and no length)
-      0xDF,
-      // stream id
-      0x01, 0x02, 0x03, 0x04,
-      // offset
-      0x3A, 0x98, 0xFE, 0xDC, 0x32, 0x10, 0x76, 0x54,
-      // data
-      'h',  'e',  'l',  'l',  'o',  ' ',  'w',  'o',  'r', 'l', 'd', '!',
-  };
-
   unsigned char packet46[] = {
       // type (long header with packet type ZERO_RTT_PROTECTED)
       0xD3,
@@ -7070,12 +6053,9 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
     p_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
   test::CompareCharArraysWithHexError("constructed packet", data->data(),
                                       data->length(), AsChars(p), p_size);
@@ -7257,7 +6237,7 @@
       0xDA, 0x5A, 0x3A, 0x3A,
       QUIC_VERSION_BYTES,
   };
-  unsigned char packet44[] = {
+  unsigned char packet46[] = {
       // type (long header)
       0xC0,
       // version tag
@@ -7292,8 +6272,8 @@
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
   } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
+    p = packet46;
+    p_size = QUIC_ARRAYSIZE(packet46);
   }
 
   QuicConnectionId connection_id = FramerTestConnectionId();
@@ -7380,27 +6360,6 @@
       0x00,
   };
 
-  unsigned char packet44[] = {
-      // type (short header, 4 byte packet number)
-      0x32,
-      // connection_id
-      0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-      // packet number
-      0x12, 0x34, 0x56, 0x78,
-
-      // frame type (ack frame)
-      // (no ack blocks, 2 byte largest observed, 2 byte block length)
-      0x45,
-      // largest acked
-      0x12, 0x34,
-      // Zero delta time.
-      0x00, 0x00,
-      // first ack block length.
-      0x12, 0x34,
-      // num timestamps.
-      0x00,
-  };
-
   unsigned char packet46[] = {
       // type (short header, 4 byte packet number)
       0x43,
@@ -7447,12 +6406,9 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
     p_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -7496,27 +6452,6 @@
       0x00,
   };
 
-  unsigned char packet44[] = {
-      // type (short header, 4 byte packet number)
-      0x32,
-      // connection_id
-      0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-      // packet number
-      0x12, 0x34, 0x56, 0x78,
-
-      // frame type (ack frame)
-      // (no ack blocks, 4 byte largest observed, 4 byte block length)
-      0x4A,
-      // largest acked
-      0x12, 0x34, 0x56, 0x78,
-      // Zero delta time.
-      0x00, 0x00,
-      // first ack block length.
-      0x12, 0x34, 0x56, 0x78,
-      // num timestamps.
-      0x00,
-  };
-
   unsigned char packet46[] = {
       // type (short header, 4 byte packet number)
       0x43,
@@ -7564,12 +6499,9 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
     p_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -7636,45 +6568,6 @@
       0x00,
   };
 
-  unsigned char packet44[] = {
-      // type (short header, 4 byte packet number)
-      0x32,
-      // connection_id
-      0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-      // packet number
-      0x12, 0x34, 0x56, 0x78,
-
-      // frame type (ack frame)
-      // (has ack blocks, 2 byte largest observed, 2 byte block length)
-      0x65,
-      // largest acked
-      0x12, 0x34,
-      // Zero delta time.
-      0x00, 0x00,
-      // num ack blocks ranges.
-      0x04,
-      // first ack block length.
-      0x00, 0x01,
-      // gap to next block.
-      0x01,
-      // ack block length.
-      0x0e, 0xaf,
-      // gap to next block.
-      0xff,
-      // ack block length.
-      0x00, 0x00,
-      // gap to next block.
-      0x91,
-      // ack block length.
-      0x01, 0xea,
-      // gap to next block.
-      0x05,
-      // ack block length.
-      0x00, 0x04,
-      // num timestamps.
-      0x00,
-  };
-
   unsigned char packet46[] = {
       // type (short header, 4 byte packet number)
       0x43,
@@ -7754,12 +6647,9 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
     p_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -7883,99 +6773,6 @@
       0x00,
   };
 
-  unsigned char packet44[] = {
-      // type (short header, 4 byte packet number)
-      0x32,
-      // connection_id
-      0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-      // packet number
-      0x12, 0x34, 0x56, 0x78,
-      // frame type (ack frame)
-      // (has ack blocks, 2 byte largest observed, 2 byte block length)
-      0x65,
-      // largest acked
-      0x12, 0x34,
-      // Zero delta time.
-      0x00, 0x00,
-      // num ack blocks ranges.
-      0xff,
-      // first ack block length.
-      0x0f, 0xdd,
-      // 255 = 4 * 63 + 3
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01,
-      // num timestamps.
-      0x00,
-  };
-
   unsigned char packet46[] = {
       // type (short header, 4 byte packet number)
       0x43,
@@ -8159,12 +6956,9 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
     p_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8252,25 +7046,6 @@
     0x05, 0x06, 0x07, 0x08,
   };
 
-  unsigned char packet44[] = {
-    // type (short packet, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (rst stream frame)
-    0x01,
-    // stream id
-    0x01, 0x02, 0x03, 0x04,
-    // sent byte offset
-    0x08, 0x07, 0x06, 0x05,
-    0x04, 0x03, 0x02, 0x01,
-    // error code
-    0x05, 0x06, 0x07, 0x08,
-  };
-
   unsigned char packet46[] = {
     // type (short packet, 4 byte packet number)
     0x43,
@@ -8319,12 +7094,9 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
     p_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
 
@@ -8375,27 +7147,6 @@
     'n',
   };
 
-  unsigned char packet44[] = {
-    // type (short header, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (connection close frame)
-    0x02,
-    // error code
-    0x05, 0x06, 0x07, 0x08,
-    // error details length
-    0x00, 0x0d,
-    // error details
-    'b',  'e',  'c',  'a',
-    'u',  's',  'e',  ' ',
-    'I',  ' ',  'c',  'a',
-    'n',
-  };
-
   unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
@@ -8446,12 +7197,9 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
     p_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8510,27 +7258,6 @@
     'n',
   };
 
-  unsigned char packet44[] = {
-    // type (short header, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (connection close frame)
-    0x02,
-    // error code
-    0x05, 0x06, 0x07, 0x08,
-    // error details length
-    0x00, 0x0d,
-    // error details
-    'b',  'e',  'c',  'a',
-    'u',  's',  'e',  ' ',
-    'I',  ' ',  'c',  'a',
-    'n',
-  };
-
   unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
@@ -8582,12 +7309,9 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
     p_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8666,55 +7390,6 @@
     'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
   };
 
-  unsigned char packet44[] = {
-    // type (short header, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (connection close frame)
-    0x02,
-    // error code
-    0x05, 0x06, 0x07, 0x08,
-    // error details length
-    0x01, 0x00,
-    // error details (truncated to 256 bytes)
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-  };
-
   unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
@@ -8821,12 +7496,9 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
     p_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -9010,29 +7682,6 @@
     'n',
   };
 
-  unsigned char packet44[] = {
-    // type (short header, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (go away frame)
-    0x03,
-    // error code
-    0x05, 0x06, 0x07, 0x08,
-    // stream id
-    0x01, 0x02, 0x03, 0x04,
-    // error details length
-    0x00, 0x0d,
-    // error details
-    'b',  'e',  'c',  'a',
-    'u',  's',  'e',  ' ',
-    'I',  ' ',  'c',  'a',
-    'n',
-  };
-
   unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
@@ -9060,12 +7709,9 @@
 
   unsigned char* p = packet;
   size_t p_size = QUIC_ARRAYSIZE(packet);
-  if (framer_.transport_version() > QUIC_VERSION_44) {
+  if (framer_.transport_version() > QUIC_VERSION_43) {
     p = packet46;
     p_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -9146,57 +7792,6 @@
     'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
   };
 
-  unsigned char packet44[] = {
-    // type (short header, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (go away frame)
-    0x03,
-    // error code
-    0x05, 0x06, 0x07, 0x08,
-    // stream id
-    0x01, 0x02, 0x03, 0x04,
-    // error details length
-    0x01, 0x00,
-    // error details (truncated to 256 bytes)
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-    'A',  'A',  'A',  'A',  'A',  'A',  'A',  'A',
-  };
-
   unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
@@ -9251,12 +7846,9 @@
 
   unsigned char* p = packet;
   size_t p_size = QUIC_ARRAYSIZE(packet);
-  if (framer_.transport_version() > QUIC_VERSION_44) {
+  if (framer_.transport_version() > QUIC_VERSION_43) {
     p = packet46;
     p_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -9298,23 +7890,6 @@
     0x55, 0x66, 0x77, 0x88,
   };
 
-  unsigned char packet44[] = {
-    // type (short header, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (window update frame)
-    0x04,
-    // stream id
-    0x01, 0x02, 0x03, 0x04,
-    // byte offset
-    0x11, 0x22, 0x33, 0x44,
-    0x55, 0x66, 0x77, 0x88,
-  };
-
   unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
@@ -9358,12 +7933,9 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
     p_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
 
   test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -9496,20 +8068,6 @@
     0x01, 0x02, 0x03, 0x04,
   };
 
-  unsigned char packet44[] = {
-    // type (short packet, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (blocked frame)
-    0x05,
-    // stream id
-    0x01, 0x02, 0x03, 0x04,
-  };
-
   unsigned char packet46[] = {
     // type (short packet, 4 byte packet number)
     0x43,
@@ -9547,12 +8105,9 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
     p_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
 
   test::CompareCharArraysWithHexError("constructed packet", data->data(),
@@ -9582,18 +8137,6 @@
     0x07,
   };
 
-  unsigned char packet44[] = {
-    // type (short header, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type
-    0x07,
-  };
-
   unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
@@ -9622,10 +8165,8 @@
   unsigned char* p = packet;
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -9633,12 +8174,12 @@
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p),
-      framer_.transport_version() > QUIC_VERSION_43 ? QUIC_ARRAYSIZE(packet44)
+      framer_.transport_version() > QUIC_VERSION_43 ? QUIC_ARRAYSIZE(packet46)
                                                     : QUIC_ARRAYSIZE(packet));
 }
 
 TEST_P(QuicFramerTest, BuildMessagePacket) {
-  if (framer_.transport_version() <= QUIC_VERSION_44) {
+  if (framer_.transport_version() <= QUIC_VERSION_43) {
     return;
   }
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
@@ -9654,26 +8195,6 @@
   QuicFrames frames = {QuicFrame(&frame), QuicFrame(&frame2)};
 
   // clang-format off
-  unsigned char packet45[] = {
-    // type (short header, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (message frame)
-    0x21,
-    // Length
-    0x07,
-    // Message Data
-    'm', 'e', 's', 's', 'a', 'g', 'e',
-    // frame type (message frame no length)
-    0x20,
-    // Message Data
-    'm', 'e', 's', 's', 'a', 'g', 'e', '2'
-  };
-
   unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
@@ -9715,11 +8236,9 @@
   };
   // clang-format on
 
-  unsigned char* p = packet45;
+  unsigned char* p = packet46;
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
-    p = packet46;
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -9727,7 +8246,7 @@
 
   test::CompareCharArraysWithHexError("constructed packet", data->data(),
                                       data->length(), AsChars(p),
-                                      QUIC_ARRAYSIZE(packet45));
+                                      QUIC_ARRAYSIZE(packet46));
 }
 
 // Test that the connectivity probing packet is serialized correctly as a
@@ -9756,21 +8275,6 @@
     0x00, 0x00, 0x00, 0x00
   };
 
-  unsigned char packet44[] = {
-    // type (short header, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type
-    0x07,
-    // frame type (padding frame)
-    0x00,
-    0x00, 0x00, 0x00, 0x00
-  };
-
   unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
@@ -9807,12 +8311,9 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     packet_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
     packet_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    packet_size = QUIC_ARRAYSIZE(packet44);
   }
 
   std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
@@ -10103,18 +8604,6 @@
     0x07,
   };
 
-  unsigned char packet44[] = {
-    // type (short header, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type
-    0x07,
-  };
-
   unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
@@ -10146,15 +8635,13 @@
   unsigned char* p = packet;
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
   }
 
   test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p),
-      framer_.transport_version() > QUIC_VERSION_43 ? QUIC_ARRAYSIZE(packet44)
+      framer_.transport_version() > QUIC_VERSION_43 ? QUIC_ARRAYSIZE(packet46)
                                                     : QUIC_ARRAYSIZE(packet));
 }
 
@@ -10325,7 +8812,7 @@
 
 TEST_P(QuicFramerTest, BuildIetfStatelessResetPacket) {
   // clang-format off
-  unsigned char packet44[] = {
+  unsigned char packet[] = {
     // type (short header, 1 byte packet number)
     0x70,
     // random packet number
@@ -10342,7 +8829,7 @@
   ASSERT_TRUE(data != nullptr);
   // Skip packet number byte which is random in stateless reset packet.
   test::CompareCharArraysWithHexError("constructed packet", data->data(), 1,
-                                      AsChars(packet44), 1);
+                                      AsChars(packet), 1);
   const size_t random_bytes_length =
       data->length() - kPacketHeaderTypeSize - sizeof(kTestStatelessResetToken);
   EXPECT_EQ(kMinRandomBytesLengthInStatelessReset, random_bytes_length);
@@ -10351,7 +8838,7 @@
       "constructed packet",
       data->data() + data->length() - sizeof(kTestStatelessResetToken),
       sizeof(kTestStatelessResetToken),
-      AsChars(packet44) + QUIC_ARRAYSIZE(packet44) -
+      AsChars(packet) + QUIC_ARRAYSIZE(packet) -
           sizeof(kTestStatelessResetToken),
       sizeof(kTestStatelessResetToken));
 }
@@ -10374,21 +8861,6 @@
     'm',  'n',  'o',  'p',
   };
 
-  unsigned char packet44[] = {
-    // type (short header, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // redundancy
-    'a',  'b',  'c',  'd',
-    'e',  'f',  'g',  'h',
-    'i',  'j',  'k',  'l',
-    'm',  'n',  'o',  'p',
-  };
-
   unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
@@ -10426,10 +8898,8 @@
   if (framer_.transport_version() == QUIC_VERSION_99) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
   }
 
   std::unique_ptr<QuicPacket> raw(new QuicPacket(
@@ -10466,25 +8936,6 @@
     'm',  'n',  'o',  'p',
   };
 
-  unsigned char packet44[] = {
-    // type (long header with packet type ZERO_RTT_PROTECTED)
-    0xFC,
-    // version tag
-    'Q', '.', '1', '0',
-    // connection_id length
-    0x50,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // redundancy
-    'a',  'b',  'c',  'd',
-    'e',  'f',  'g',  'h',
-    'i',  'j',  'k',  'l',
-    'm',  'n',  'o',  'p',
-  };
-
   unsigned char packet46[] = {
     // type (long header with packet type ZERO_RTT_PROTECTED)
     0xD3,
@@ -10533,12 +8984,9 @@
   if (framer_.transport_version() == QUIC_VERSION_99) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
     p_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
 
   std::unique_ptr<QuicPacket> raw(new QuicPacket(
@@ -10721,43 +9169,6 @@
     0x9A, 0xBE,
   };
 
-  unsigned char packet44[] = {
-    // type (short header, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (stream frame with fin)
-    0xFF,
-    // stream id
-    0x01, 0x02, 0x03, 0x04,
-    // offset
-    0x3A, 0x98, 0xFE, 0xDC,
-    0x32, 0x10, 0x76, 0x54,
-    // data length
-    0x00, 0x0c,
-    // data
-    'h',  'e',  'l',  'l',
-    'o',  ' ',  'w',  'o',
-    'r',  'l',  'd',  '!',
-
-    // frame type (ack frame)
-    0x40,
-    // least packet number awaiting an ack
-    0x12, 0x34, 0x56, 0x78,
-    0x9A, 0xA0,
-    // largest observed packet number
-    0x12, 0x34, 0x56, 0x78,
-    0x9A, 0xBF,
-    // num missing packets
-    0x01,
-    // missing packet
-    0x12, 0x34, 0x56, 0x78,
-    0x9A, 0xBE,
-  };
-
   unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
@@ -10849,12 +9260,9 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
     p_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -13353,26 +11761,6 @@
     0x00
   };
 
-  unsigned char packet44[] = {
-    // type (short header, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (ack frame)
-    0x45,
-    // largest observed
-    0x00, 0x00,
-    // Zero delta time.
-    0x00, 0x00,
-    // first ack block length.
-    0x00, 0x00,
-    // num timestamps.
-    0x00
-  };
-
   unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
@@ -13419,11 +11807,8 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -13454,26 +11839,6 @@
     0x00
   };
 
-  unsigned char packet44[] = {
-    // type (short header, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (ack frame)
-    0x45,
-    // largest observed
-    0x00, 0x02,
-    // Zero delta time.
-    0x00, 0x00,
-    // first ack block length.
-    0x00, 0x03,
-    // num timestamps.
-    0x00
-  };
-
   unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
@@ -13520,12 +11885,9 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
     p_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -13567,36 +11929,6 @@
     0x00
   };
 
-  unsigned char packet44[] = {
-    // type (short header, 4 byte packet number)
-    0x32,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (ack frame)
-    0x60,
-    // largest observed
-    0x0A,
-    // Zero delta time.
-    0x00, 0x00,
-    // Num of ack blocks
-    0x02,
-    // first ack block length.
-    0x02,
-    // gap to next block
-    0x01,
-    // ack block length
-    0x01,
-    // gap to next block
-    0x01,
-    // ack block length
-    0x06,
-    // num timestamps.
-    0x00
-  };
-
   unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
@@ -13661,12 +11993,9 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() > QUIC_VERSION_44) {
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
     p = packet46;
     p_size = QUIC_ARRAYSIZE(packet46);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
-    p = packet44;
-    p_size = QUIC_ARRAYSIZE(packet44);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -13795,8 +12124,6 @@
                          std::move(bogus_crypters.decrypter));
   }
 
-  const unsigned char type_byte =
-      framer_.transport_version() == QUIC_VERSION_44 ? 0xFC : 0xE3;
   // clang-format off
   unsigned char packet[] = {
     // public flags (version included, 8-byte connection ID,
@@ -13812,10 +12139,10 @@
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   };
-  unsigned char packet44[] = {
+  unsigned char packet46[] = {
     // public flags (long header with packet type HANDSHAKE and
     // 4-byte packet number)
-    type_byte,
+    0xE3,
     // version
     QUIC_VERSION_BYTES,
     // connection ID lengths
@@ -13860,9 +12187,9 @@
   if (framer_.transport_version() == QUIC_VERSION_99) {
     p = packet99;
     p_length = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() >= QUIC_VERSION_44) {
-    p = packet44;
-    p_length = QUIC_ARRAYSIZE(packet44);
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+    p = packet46;
+    p_length = QUIC_ARRAYSIZE(packet46);
   }
   // First attempt decryption without the handshake crypter.
   EXPECT_FALSE(
@@ -13905,8 +12232,6 @@
                          std::move(bad_handshake_crypters.decrypter));
   }
 
-  const unsigned char type_byte =
-      framer_.transport_version() == QUIC_VERSION_44 ? 0xFC : 0xE3;
   // clang-format off
   unsigned char packet[] = {
     // public flags (version included, 8-byte connection ID,
@@ -13922,10 +12247,10 @@
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   };
-  unsigned char packet44[] = {
+  unsigned char packet46[] = {
     // public flags (long header with packet type HANDSHAKE and
     // 4-byte packet number)
-    type_byte,
+    0xE3,
     // version
     QUIC_VERSION_BYTES,
     // connection ID lengths
@@ -13970,9 +12295,9 @@
   if (framer_.transport_version() == QUIC_VERSION_99) {
     p = packet99;
     p_length = QUIC_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() >= QUIC_VERSION_44) {
-    p = packet44;
-    p_length = QUIC_ARRAYSIZE(packet44);
+  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+    p = packet46;
+    p_length = QUIC_ARRAYSIZE(packet46);
   }
 
   EXPECT_FALSE(
@@ -14323,7 +12648,7 @@
 }
 
 TEST_P(QuicFramerTest, ClientReceivesInvalidVersion) {
-  if (framer_.transport_version() < QUIC_VERSION_44) {
+  if (framer_.transport_version() <= QUIC_VERSION_43) {
     return;
   }
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
@@ -14331,7 +12656,7 @@
   // clang-format off
   unsigned char packet[] = {
        // public flags (long header with packet type INITIAL)
-       0xFF,
+       0xC3,
        // version that is different from the framer's version
        'Q', '0', '4', '3',
        // connection ID lengths
@@ -14528,21 +12853,7 @@
   }
 
   // clang-format off
-  PacketFragments packet = {
-    // public flags (IETF Retry packet, 0-length original destination CID)
-    {"Unable to read first byte.",
-     {0xf0}},
-    // version tag
-    {"Unable to read protocol version.",
-     {QUIC_VERSION_BYTES}},
-    // connection_id length
-    {"Illegal long header type value.",
-     {0x00}},
-  };
-  // clang-format on
-
-  // clang-format off
-  PacketFragments packet45 = {
+  PacketFragments packet46 = {
     // public flags (IETF Retry packet, 0-length original destination CID)
     {"Unable to read first byte.",
      {0xf0}},
@@ -14555,14 +12866,12 @@
   };
   // clang-format on
 
-  PacketFragments& fragments =
-      framer_.transport_version() > QUIC_VERSION_44 ? packet45 : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
-      AssemblePacketFromFragments(fragments));
+      AssemblePacketFromFragments(packet46));
 
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
   EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, framer_.error());
-  CheckFramingBoundaries(fragments, QUIC_INVALID_PACKET_HEADER);
+  CheckFramingBoundaries(packet46, QUIC_INVALID_PACKET_HEADER);
 }
 
 TEST_P(QuicFramerTest, RetryPacketRejectedWithMultiplePacketNumberSpaces) {
@@ -15095,13 +13404,11 @@
   }
   SetDecrypterLevel(ENCRYPTION_HANDSHAKE);
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
-  const unsigned char type_byte =
-      framer_.transport_version() == QUIC_VERSION_44 ? 0xFC : 0xE3;
   // clang-format off
   unsigned char packet[] = {
     // public flags (long header with packet type HANDSHAKE and
     // 4-byte packet number)
-    type_byte,
+    0xE3,
     // version
     QUIC_VERSION_BYTES,
     // connection ID lengths
@@ -15165,13 +13472,11 @@
   }
   SetDecrypterLevel(ENCRYPTION_HANDSHAKE);
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_SERVER);
-  const unsigned char type_byte =
-      framer_.transport_version() == QUIC_VERSION_44 ? 0xFC : 0xE3;
   // clang-format off
   unsigned char packet[] = {
     // public flags (long header with packet type HANDSHAKE and
     // 4-byte packet number)
-    type_byte,
+    0xE3,
     // version
     QUIC_VERSION_BYTES,
     // connection ID lengths
diff --git a/quic/core/quic_packets.cc b/quic/core/quic_packets.cc
index 80336d4..2d6d0c9 100644
--- a/quic/core/quic_packets.cc
+++ b/quic/core/quic_packets.cc
@@ -118,9 +118,7 @@
       // Long header.
       size_t size = kPacketHeaderTypeSize + kConnectionIdLengthSize +
                     destination_connection_id_length +
-                    source_connection_id_length +
-                    (version > QUIC_VERSION_44 ? packet_number_length
-                                               : PACKET_4BYTE_PACKET_NUMBER) +
+                    source_connection_id_length + packet_number_length +
                     kQuicVersionSize;
       if (include_diversification_nonce) {
         size += kDiversificationNonceSize;
diff --git a/quic/core/quic_types.h b/quic/core/quic_types.h
index 524d5ec..cb90505 100644
--- a/quic/core/quic_types.h
+++ b/quic/core/quic_types.h
@@ -302,7 +302,7 @@
 enum QuicPacketNumberLength : uint8_t {
   PACKET_1BYTE_PACKET_NUMBER = 1,
   PACKET_2BYTE_PACKET_NUMBER = 2,
-  PACKET_3BYTE_PACKET_NUMBER = 3,  // Used in version > QUIC_VERSION_44.
+  PACKET_3BYTE_PACKET_NUMBER = 3,  // Used in versions 45+.
   PACKET_4BYTE_PACKET_NUMBER = 4,
   IETF_MAX_PACKET_NUMBER_LENGTH = 4,
   // TODO(rch): Remove this when we remove QUIC_VERSION_39.
diff --git a/quic/core/quic_version_manager.cc b/quic/core/quic_version_manager.cc
index 7c658f7..6b2f60e 100644
--- a/quic/core/quic_version_manager.cc
+++ b/quic/core/quic_version_manager.cc
@@ -17,7 +17,6 @@
     : enable_version_99_(GetQuicReloadableFlag(quic_enable_version_99)),
       enable_version_48_(GetQuicReloadableFlag(quic_enable_version_48_2)),
       enable_version_47_(GetQuicReloadableFlag(quic_enable_version_47)),
-      disable_version_44_(GetQuicReloadableFlag(quic_disable_version_44)),
       disable_version_39_(GetQuicReloadableFlag(quic_disable_version_39)),
       enable_tls_(GetQuicFlag(FLAGS_quic_supports_tls_handshake)),
       allowed_supported_versions_(std::move(supported_versions)) {
@@ -41,13 +40,11 @@
   if (enable_version_99_ != GetQuicReloadableFlag(quic_enable_version_99) ||
       enable_version_48_ != GetQuicReloadableFlag(quic_enable_version_48_2) ||
       enable_version_47_ != GetQuicReloadableFlag(quic_enable_version_47) ||
-      disable_version_44_ != GetQuicReloadableFlag(quic_disable_version_44) ||
       disable_version_39_ != GetQuicReloadableFlag(quic_disable_version_39) ||
       enable_tls_ != GetQuicFlag(FLAGS_quic_supports_tls_handshake)) {
     enable_version_99_ = GetQuicReloadableFlag(quic_enable_version_99);
     enable_version_48_ = GetQuicReloadableFlag(quic_enable_version_48_2);
     enable_version_47_ = GetQuicReloadableFlag(quic_enable_version_47);
-    disable_version_44_ = GetQuicReloadableFlag(quic_disable_version_44);
     disable_version_39_ = GetQuicReloadableFlag(quic_disable_version_39);
     enable_tls_ = GetQuicFlag(FLAGS_quic_supports_tls_handshake);
     RefilterSupportedVersions();
diff --git a/quic/core/quic_version_manager.h b/quic/core/quic_version_manager.h
index b442a4c..7f34a49 100644
--- a/quic/core/quic_version_manager.h
+++ b/quic/core/quic_version_manager.h
@@ -44,8 +44,6 @@
   bool enable_version_48_;
   // quic_enable_version_47 flag
   bool enable_version_47_;
-  // quic_disable_version_44 flag
-  bool disable_version_44_;
   // quic_disable_version_39 flag
   bool disable_version_39_;
   // quic_supports_tls_handshake flag
diff --git a/quic/core/quic_version_manager_test.cc b/quic/core/quic_version_manager_test.cc
index 645f778..50b0229 100644
--- a/quic/core/quic_version_manager_test.cc
+++ b/quic/core/quic_version_manager_test.cc
@@ -16,12 +16,11 @@
 class QuicVersionManagerTest : public QuicTest {};
 
 TEST_F(QuicVersionManagerTest, QuicVersionManager) {
-  static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 7u,
+  static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
                 "Supported versions out of sync");
   SetQuicReloadableFlag(quic_enable_version_99, false);
   SetQuicReloadableFlag(quic_enable_version_48_2, false);
   SetQuicReloadableFlag(quic_enable_version_47, false);
-  SetQuicReloadableFlag(quic_disable_version_44, true);
   SetQuicReloadableFlag(quic_disable_version_39, true);
   QuicVersionManager manager(AllSupportedVersions());
 
@@ -36,29 +35,22 @@
                 {QUIC_VERSION_46, QUIC_VERSION_43, QUIC_VERSION_39}),
             manager.GetSupportedTransportVersions());
 
-  SetQuicReloadableFlag(quic_disable_version_44, false);
-  EXPECT_EQ(QuicTransportVersionVector({QUIC_VERSION_46, QUIC_VERSION_44,
-                                        QUIC_VERSION_43, QUIC_VERSION_39}),
-            manager.GetSupportedTransportVersions());
-
   SetQuicReloadableFlag(quic_enable_version_47, true);
   EXPECT_EQ(QuicTransportVersionVector({QUIC_VERSION_47, QUIC_VERSION_46,
-                                        QUIC_VERSION_44, QUIC_VERSION_43,
-                                        QUIC_VERSION_39}),
+                                        QUIC_VERSION_43, QUIC_VERSION_39}),
             manager.GetSupportedTransportVersions());
 
   SetQuicReloadableFlag(quic_enable_version_48_2, true);
   EXPECT_EQ(QuicTransportVersionVector({QUIC_VERSION_48, QUIC_VERSION_47,
-                                        QUIC_VERSION_46, QUIC_VERSION_44,
-                                        QUIC_VERSION_43, QUIC_VERSION_39}),
+                                        QUIC_VERSION_46, QUIC_VERSION_43,
+                                        QUIC_VERSION_39}),
             manager.GetSupportedTransportVersions());
 
   SetQuicReloadableFlag(quic_enable_version_99, true);
-  EXPECT_EQ(
-      QuicTransportVersionVector(
-          {QUIC_VERSION_99, QUIC_VERSION_48, QUIC_VERSION_47, QUIC_VERSION_46,
-           QUIC_VERSION_44, QUIC_VERSION_43, QUIC_VERSION_39}),
-      manager.GetSupportedTransportVersions());
+  EXPECT_EQ(QuicTransportVersionVector({QUIC_VERSION_99, QUIC_VERSION_48,
+                                        QUIC_VERSION_47, QUIC_VERSION_46,
+                                        QUIC_VERSION_43, QUIC_VERSION_39}),
+            manager.GetSupportedTransportVersions());
 
   // Ensure that all versions are now supported.
   EXPECT_EQ(FilterSupportedTransportVersions(AllSupportedTransportVersions()),
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index d4f4b42..372c4f7 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -108,8 +108,6 @@
       return MakeVersionLabel(proto, '0', '3', '9');
     case QUIC_VERSION_43:
       return MakeVersionLabel(proto, '0', '4', '3');
-    case QUIC_VERSION_44:
-      return MakeVersionLabel(proto, '0', '4', '4');
     case QUIC_VERSION_46:
       return MakeVersionLabel(proto, '0', '4', '6');
     case QUIC_VERSION_47:
@@ -266,10 +264,6 @@
       if (GetQuicReloadableFlag(quic_enable_version_47)) {
         filtered_versions.push_back(version);
       }
-    } else if (version.transport_version == QUIC_VERSION_44) {
-      if (!GetQuicReloadableFlag(quic_disable_version_44)) {
-        filtered_versions.push_back(version);
-      }
     } else if (version.transport_version == QUIC_VERSION_39) {
       if (!GetQuicReloadableFlag(quic_disable_version_39)) {
         filtered_versions.push_back(version);
@@ -364,7 +358,6 @@
   switch (transport_version) {
     RETURN_STRING_LITERAL(QUIC_VERSION_39);
     RETURN_STRING_LITERAL(QUIC_VERSION_43);
-    RETURN_STRING_LITERAL(QUIC_VERSION_44);
     RETURN_STRING_LITERAL(QUIC_VERSION_46);
     RETURN_STRING_LITERAL(QUIC_VERSION_47);
     RETURN_STRING_LITERAL(QUIC_VERSION_48);
@@ -482,7 +475,7 @@
   if (parsed_version.handshake_protocol == PROTOCOL_TLS1_3) {
     SetQuicFlag(FLAGS_quic_supports_tls_handshake, true);
   }
-  static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 7u,
+  static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
                 "Supported versions out of sync");
   if (parsed_version.transport_version == QUIC_VERSION_99) {
     SetQuicReloadableFlag(quic_enable_version_99, true);
diff --git a/quic/core/quic_versions.h b/quic/core/quic_versions.h
index 45caa03..f82f300 100644
--- a/quic/core/quic_versions.h
+++ b/quic/core/quic_versions.h
@@ -97,7 +97,7 @@
 
   QUIC_VERSION_43 = 43,  // PRIORITY frames are sent by client and accepted by
                          // server.
-  QUIC_VERSION_44 = 44,  // Use IETF header format.
+  // Version 44 used IETF header format from draft-ietf-quic-invariants-05.
 
   // Version 45 added MESSAGE frame.
 
@@ -200,8 +200,8 @@
 //
 // See go/new-quic-version for more details on how to roll out new versions.
 static const QuicTransportVersion kSupportedTransportVersions[] = {
-    QUIC_VERSION_99, QUIC_VERSION_48, QUIC_VERSION_47, QUIC_VERSION_46,
-    QUIC_VERSION_44, QUIC_VERSION_43, QUIC_VERSION_39,
+    QUIC_VERSION_99, QUIC_VERSION_48, QUIC_VERSION_47,
+    QUIC_VERSION_46, QUIC_VERSION_43, QUIC_VERSION_39,
 };
 
 // This vector contains all crypto handshake protocols that are supported.
@@ -357,7 +357,7 @@
 // Returns true if |transport_version| supports MESSAGE frames.
 QUIC_EXPORT_PRIVATE inline bool VersionSupportsMessageFrames(
     QuicTransportVersion transport_version) {
-  return transport_version > QUIC_VERSION_44;
+  return transport_version >= QUIC_VERSION_46;
 }
 
 // Returns true if QuicSpdyStream encodes body using HTTP/3 specification and
diff --git a/quic/core/quic_versions_test.cc b/quic/core/quic_versions_test.cc
index f6223e7..99f4eb4 100644
--- a/quic/core/quic_versions_test.cc
+++ b/quic/core/quic_versions_test.cc
@@ -116,8 +116,6 @@
             ParseQuicVersionLabel(MakeVersionLabel('Q', '0', '3', '9')));
   EXPECT_EQ(ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_43),
             ParseQuicVersionLabel(MakeVersionLabel('Q', '0', '4', '3')));
-  EXPECT_EQ(ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_44),
-            ParseQuicVersionLabel(MakeVersionLabel('Q', '0', '4', '4')));
   EXPECT_EQ(ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_46),
             ParseQuicVersionLabel(MakeVersionLabel('Q', '0', '4', '6')));
   EXPECT_EQ(ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_47),
@@ -130,8 +128,6 @@
             ParseQuicVersionLabel(MakeVersionLabel('T', '0', '3', '9')));
   EXPECT_EQ(ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_43),
             ParseQuicVersionLabel(MakeVersionLabel('T', '0', '4', '3')));
-  EXPECT_EQ(ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_44),
-            ParseQuicVersionLabel(MakeVersionLabel('T', '0', '4', '4')));
   EXPECT_EQ(ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_46),
             ParseQuicVersionLabel(MakeVersionLabel('T', '0', '4', '6')));
   EXPECT_EQ(ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_47),
@@ -145,8 +141,6 @@
             ParseQuicVersionString("Q039"));
   EXPECT_EQ(ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_43),
             ParseQuicVersionString("Q043"));
-  EXPECT_EQ(ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_44),
-            ParseQuicVersionString("Q044"));
   EXPECT_EQ(ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_46),
             ParseQuicVersionString("Q046"));
   EXPECT_EQ(ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_47),
@@ -164,8 +158,6 @@
             ParseQuicVersionString("T039"));
   EXPECT_EQ(ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_43),
             ParseQuicVersionString("T043"));
-  EXPECT_EQ(ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_44),
-            ParseQuicVersionString("T044"));
   EXPECT_EQ(ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_46),
             ParseQuicVersionString("T046"));
   EXPECT_EQ(ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_47),
@@ -181,9 +173,6 @@
   EXPECT_EQ(MakeVersionLabel('Q', '0', '4', '3'),
             CreateQuicVersionLabel(
                 ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_43)));
-  EXPECT_EQ(MakeVersionLabel('Q', '0', '4', '4'),
-            CreateQuicVersionLabel(
-                ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_44)));
   EXPECT_EQ(MakeVersionLabel('Q', '0', '4', '6'),
             CreateQuicVersionLabel(
                 ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_46)));
@@ -201,9 +190,6 @@
   EXPECT_EQ(MakeVersionLabel('T', '0', '4', '3'),
             CreateQuicVersionLabel(
                 ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_43)));
-  EXPECT_EQ(MakeVersionLabel('T', '0', '4', '4'),
-            CreateQuicVersionLabel(
-                ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_44)));
   EXPECT_EQ(MakeVersionLabel('T', '0', '4', '6'),
             CreateQuicVersionLabel(
                 ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_46)));
@@ -308,7 +294,6 @@
 TEST_F(QuicVersionsTest, FilterSupportedTransportVersionsAllVersions) {
   QuicTransportVersionVector all_versions = AllSupportedTransportVersions();
   SetQuicReloadableFlag(quic_disable_version_39, false);
-  SetQuicReloadableFlag(quic_disable_version_44, false);
   SetQuicReloadableFlag(quic_enable_version_47, true);
   SetQuicReloadableFlag(quic_enable_version_48_2, true);
   SetQuicReloadableFlag(quic_enable_version_99, true);
@@ -317,8 +302,8 @@
     parsed_versions.push_back(ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, version));
   }
   QuicTransportVersionVector expected_versions = {
-      QUIC_VERSION_99, QUIC_VERSION_48, QUIC_VERSION_47, QUIC_VERSION_46,
-      QUIC_VERSION_44, QUIC_VERSION_43, QUIC_VERSION_39};
+      QUIC_VERSION_99, QUIC_VERSION_48, QUIC_VERSION_47,
+      QUIC_VERSION_46, QUIC_VERSION_43, QUIC_VERSION_39};
   ParsedQuicVersionVector expected_parsed_versions;
   for (QuicTransportVersion version : expected_versions) {
     expected_parsed_versions.push_back(
@@ -332,7 +317,6 @@
 TEST_F(QuicVersionsTest, FilterSupportedTransportVersionsNo99) {
   QuicTransportVersionVector all_versions = AllSupportedTransportVersions();
   SetQuicReloadableFlag(quic_disable_version_39, false);
-  SetQuicReloadableFlag(quic_disable_version_44, false);
   SetQuicReloadableFlag(quic_enable_version_47, true);
   SetQuicReloadableFlag(quic_enable_version_48_2, true);
   SetQuicReloadableFlag(quic_enable_version_99, false);
@@ -341,8 +325,8 @@
     parsed_versions.push_back(ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, version));
   }
   QuicTransportVersionVector expected_versions = {
-      QUIC_VERSION_48, QUIC_VERSION_47, QUIC_VERSION_46,
-      QUIC_VERSION_44, QUIC_VERSION_43, QUIC_VERSION_39};
+      QUIC_VERSION_48, QUIC_VERSION_47, QUIC_VERSION_46, QUIC_VERSION_43,
+      QUIC_VERSION_39};
   ParsedQuicVersionVector expected_parsed_versions;
   for (QuicTransportVersion version : expected_versions) {
     expected_parsed_versions.push_back(
@@ -356,7 +340,6 @@
 TEST_F(QuicVersionsTest, FilterSupportedTransportVersionsNo48) {
   QuicTransportVersionVector all_versions = AllSupportedTransportVersions();
   SetQuicReloadableFlag(quic_disable_version_39, false);
-  SetQuicReloadableFlag(quic_disable_version_44, false);
   SetQuicReloadableFlag(quic_enable_version_47, true);
   SetQuicReloadableFlag(quic_enable_version_48_2, false);
   SetQuicReloadableFlag(quic_enable_version_99, false);
@@ -365,8 +348,7 @@
     parsed_versions.push_back(ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, version));
   }
   QuicTransportVersionVector expected_versions = {
-      QUIC_VERSION_47, QUIC_VERSION_46, QUIC_VERSION_44, QUIC_VERSION_43,
-      QUIC_VERSION_39};
+      QUIC_VERSION_47, QUIC_VERSION_46, QUIC_VERSION_43, QUIC_VERSION_39};
   ParsedQuicVersionVector expected_parsed_versions;
   for (QuicTransportVersion version : expected_versions) {
     expected_parsed_versions.push_back(
@@ -380,30 +362,6 @@
 TEST_F(QuicVersionsTest, FilterSupportedTransportVersionsNo47) {
   QuicTransportVersionVector all_versions = AllSupportedTransportVersions();
   SetQuicReloadableFlag(quic_disable_version_39, false);
-  SetQuicReloadableFlag(quic_disable_version_44, false);
-  SetQuicReloadableFlag(quic_enable_version_47, false);
-  SetQuicReloadableFlag(quic_enable_version_48_2, false);
-  SetQuicReloadableFlag(quic_enable_version_99, false);
-  ParsedQuicVersionVector parsed_versions;
-  for (QuicTransportVersion version : all_versions) {
-    parsed_versions.push_back(ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, version));
-  }
-  QuicTransportVersionVector expected_versions = {
-      QUIC_VERSION_46, QUIC_VERSION_44, QUIC_VERSION_43, QUIC_VERSION_39};
-  ParsedQuicVersionVector expected_parsed_versions;
-  for (QuicTransportVersion version : expected_versions) {
-    expected_parsed_versions.push_back(
-        ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, version));
-  }
-
-  ASSERT_EQ(expected_versions, FilterSupportedTransportVersions(all_versions));
-  ASSERT_EQ(expected_parsed_versions, FilterSupportedVersions(parsed_versions));
-}
-
-TEST_F(QuicVersionsTest, FilterSupportedTransportVersionsNo44) {
-  QuicTransportVersionVector all_versions = AllSupportedTransportVersions();
-  SetQuicReloadableFlag(quic_disable_version_39, false);
-  SetQuicReloadableFlag(quic_disable_version_44, true);
   SetQuicReloadableFlag(quic_enable_version_47, false);
   SetQuicReloadableFlag(quic_enable_version_48_2, false);
   SetQuicReloadableFlag(quic_enable_version_99, false);
@@ -426,7 +384,6 @@
 TEST_F(QuicVersionsTest, FilterSupportedTransportVersionsNo39) {
   QuicTransportVersionVector all_versions = AllSupportedTransportVersions();
   SetQuicReloadableFlag(quic_disable_version_39, true);
-  SetQuicReloadableFlag(quic_disable_version_44, false);
   SetQuicReloadableFlag(quic_enable_version_47, false);
   SetQuicReloadableFlag(quic_enable_version_48_2, false);
   SetQuicReloadableFlag(quic_enable_version_99, false);
@@ -434,8 +391,8 @@
   for (QuicTransportVersion version : all_versions) {
     parsed_versions.push_back(ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, version));
   }
-  QuicTransportVersionVector expected_versions = {
-      QUIC_VERSION_46, QUIC_VERSION_44, QUIC_VERSION_43};
+  QuicTransportVersionVector expected_versions = {QUIC_VERSION_46,
+                                                  QUIC_VERSION_43};
   ParsedQuicVersionVector expected_parsed_versions;
   for (QuicTransportVersion version : expected_versions) {
     expected_parsed_versions.push_back(
@@ -485,11 +442,10 @@
 // yet a typo was made in doing the #defines and it was caught
 // only in some test far removed from here... Better safe than sorry.
 TEST_F(QuicVersionsTest, CheckVersionNumbersForTypos) {
-  static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 7u,
+  static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
                 "Supported versions out of sync");
   EXPECT_EQ(QUIC_VERSION_39, 39);
   EXPECT_EQ(QUIC_VERSION_43, 43);
-  EXPECT_EQ(QUIC_VERSION_44, 44);
   EXPECT_EQ(QUIC_VERSION_46, 46);
   EXPECT_EQ(QUIC_VERSION_47, 47);
   EXPECT_EQ(QUIC_VERSION_48, 48);
@@ -554,7 +510,6 @@
       ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99);
   SetQuicFlag(FLAGS_quic_supports_tls_handshake, false);
   SetQuicReloadableFlag(quic_disable_version_39, false);
-  SetQuicReloadableFlag(quic_disable_version_44, false);
   SetQuicReloadableFlag(quic_enable_version_47, false);
   SetQuicReloadableFlag(quic_enable_version_48_2, false);
   SetQuicReloadableFlag(quic_enable_version_99, false);