diff --git a/quiche/quic/core/chlo_extractor.cc b/quiche/quic/core/chlo_extractor.cc
index e55df8a..a663432 100644
--- a/quiche/quic/core/chlo_extractor.cc
+++ b/quiche/quic/core/chlo_extractor.cc
@@ -33,7 +33,6 @@
   void OnError(QuicFramer* /*framer*/) override {}
   bool OnProtocolVersionMismatch(ParsedQuicVersion version) override;
   void OnPacket() override {}
-  void OnPublicResetPacket(const QuicPublicResetPacket& /*packet*/) override {}
   void OnVersionNegotiationPacket(
       const QuicVersionNegotiationPacket& /*packet*/) override {}
   void OnRetryPacket(QuicConnectionId /*original_connection_id*/,
diff --git a/quiche/quic/core/crypto/crypto_utils.cc b/quiche/quic/core/crypto/crypto_utils.cc
index 01fb681..9ce176e 100644
--- a/quiche/quic/core/crypto/crypto_utils.cc
+++ b/quiche/quic/core/crypto/crypto_utils.cc
@@ -94,7 +94,7 @@
 
 const std::string getLabelForVersion(const ParsedQuicVersion& version,
                                      const absl::string_view& predicate) {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync with HKDF labels");
   if (version == ParsedQuicVersion::V2Draft08()) {
     return absl::StrCat("quicv2 ", predicate);
@@ -172,7 +172,7 @@
 
 const uint8_t* InitialSaltForVersion(const ParsedQuicVersion& version,
                                      size_t* out_len) {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync with initial encryption salts");
   if (version == ParsedQuicVersion::V2Draft08()) {
     *out_len = ABSL_ARRAYSIZE(kV2Draft08InitialSalt);
@@ -230,7 +230,7 @@
 bool RetryIntegrityKeysForVersion(const ParsedQuicVersion& version,
                                   absl::string_view* key,
                                   absl::string_view* nonce) {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync with retry integrity keys");
   if (!version.UsesTls()) {
     QUIC_BUG(quic_bug_10699_2)
diff --git a/quiche/quic/core/http/end_to_end_test.cc b/quiche/quic/core/http/end_to_end_test.cc
index fd71300..44e3abe 100644
--- a/quiche/quic/core/http/end_to_end_test.cc
+++ b/quiche/quic/core/http/end_to_end_test.cc
@@ -679,8 +679,7 @@
   }
 
   bool SupportsIetfQuicWithTls(ParsedQuicVersion version) {
-    return version.HasIetfInvariantHeader() &&
-           version.handshake_protocol == PROTOCOL_TLS1_3;
+    return version.handshake_protocol == PROTOCOL_TLS1_3;
   }
 
   static void ExpectFlowControlsSynced(QuicSession* client,
@@ -2747,58 +2746,6 @@
   server_thread_->Resume();
 }
 
-TEST_P(EndToEndTest, 0ByteConnectionId) {
-  if (version_.HasIetfInvariantHeader()) {
-    // SetBytesForConnectionIdToSend only applies to Google QUIC encoding.
-    ASSERT_TRUE(Initialize());
-    return;
-  }
-  client_config_.SetBytesForConnectionIdToSend(0);
-  ASSERT_TRUE(Initialize());
-
-  SendSynchronousFooRequestAndCheckResponse();
-  QuicConnection* client_connection = GetClientConnection();
-  ASSERT_TRUE(client_connection);
-  QuicPacketHeader* header =
-      QuicConnectionPeer::GetLastHeader(client_connection);
-  EXPECT_EQ(CONNECTION_ID_ABSENT, header->source_connection_id_included);
-}
-
-TEST_P(EndToEndTest, 8ByteConnectionId) {
-  if (version_.HasIetfInvariantHeader()) {
-    // SetBytesForConnectionIdToSend only applies to Google QUIC encoding.
-    ASSERT_TRUE(Initialize());
-    return;
-  }
-  client_config_.SetBytesForConnectionIdToSend(8);
-  ASSERT_TRUE(Initialize());
-
-  SendSynchronousFooRequestAndCheckResponse();
-  QuicConnection* client_connection = GetClientConnection();
-  ASSERT_TRUE(client_connection);
-  QuicPacketHeader* header =
-      QuicConnectionPeer::GetLastHeader(client_connection);
-  EXPECT_EQ(CONNECTION_ID_PRESENT, header->destination_connection_id_included);
-}
-
-TEST_P(EndToEndTest, 15ByteConnectionId) {
-  if (version_.HasIetfInvariantHeader()) {
-    // SetBytesForConnectionIdToSend only applies to Google QUIC encoding.
-    ASSERT_TRUE(Initialize());
-    return;
-  }
-  client_config_.SetBytesForConnectionIdToSend(15);
-  ASSERT_TRUE(Initialize());
-
-  // Our server is permissive and allows for out of bounds values.
-  SendSynchronousFooRequestAndCheckResponse();
-  QuicConnection* client_connection = GetClientConnection();
-  ASSERT_TRUE(client_connection);
-  QuicPacketHeader* header =
-      QuicConnectionPeer::GetLastHeader(client_connection);
-  EXPECT_EQ(CONNECTION_ID_PRESENT, header->destination_connection_id_included);
-}
-
 TEST_P(EndToEndTest, ResetConnection) {
   ASSERT_TRUE(Initialize());
 
@@ -4039,17 +3986,11 @@
   QuicConnection* client_connection = GetClientConnection();
   ASSERT_TRUE(client_connection);
   QuicConnectionId connection_id = client_connection->connection_id();
-  QuicPublicResetPacket header;
-  header.connection_id = connection_id;
   QuicFramer framer(server_supported_versions_, QuicTime::Zero(),
                     Perspective::IS_SERVER, kQuicDefaultConnectionIdLength);
-  std::unique_ptr<QuicEncryptedPacket> packet;
-  if (version_.HasIetfInvariantHeader()) {
-    packet = framer.BuildIetfStatelessResetPacket(
-        connection_id, /*received_packet_length=*/100, stateless_reset_token);
-  } else {
-    packet = framer.BuildPublicResetPacket(header);
-  }
+  std::unique_ptr<QuicEncryptedPacket> packet =
+      framer.BuildIetfStatelessResetPacket(
+          connection_id, /*received_packet_length=*/100, stateless_reset_token);
   // We must pause the server's thread in order to call WritePacket without
   // race conditions.
   server_thread_->Pause();
@@ -4082,24 +4023,16 @@
   ASSERT_TRUE(client_connection);
   QuicConnectionId incorrect_connection_id = TestConnectionId(
       TestConnectionIdToUInt64(client_connection->connection_id()) + 1);
-  QuicPublicResetPacket header;
-  header.connection_id = incorrect_connection_id;
   QuicFramer framer(server_supported_versions_, QuicTime::Zero(),
                     Perspective::IS_SERVER, kQuicDefaultConnectionIdLength);
-  std::unique_ptr<QuicEncryptedPacket> packet;
   NiceMock<MockQuicConnectionDebugVisitor> visitor;
   client_connection->set_debug_visitor(&visitor);
-  if (version_.HasIetfInvariantHeader()) {
-    packet = framer.BuildIetfStatelessResetPacket(
-        incorrect_connection_id, /*received_packet_length=*/100,
-        stateless_reset_token);
-    EXPECT_CALL(visitor, OnIncorrectConnectionId(incorrect_connection_id))
-        .Times(0);
-  } else {
-    packet = framer.BuildPublicResetPacket(header);
-    EXPECT_CALL(visitor, OnIncorrectConnectionId(incorrect_connection_id))
-        .Times(1);
-  }
+  std::unique_ptr<QuicEncryptedPacket> packet =
+      framer.BuildIetfStatelessResetPacket(incorrect_connection_id,
+                                           /*received_packet_length=*/100,
+                                           stateless_reset_token);
+  EXPECT_CALL(visitor, OnIncorrectConnectionId(incorrect_connection_id))
+      .Times(0);
   // We must pause the server's thread in order to call WritePacket without
   // race conditions.
   server_thread_->Pause();
@@ -4108,16 +4041,11 @@
                               server_address_.host(), client_address, nullptr);
   server_thread_->Resume();
 
-  if (version_.HasIetfInvariantHeader()) {
-    // The request should fail. IETF stateless reset does not include connection
-    // ID.
-    EXPECT_EQ("", client_->SendSynchronousRequest("/foo"));
-    EXPECT_TRUE(client_->response_headers()->empty());
-    EXPECT_THAT(client_->connection_error(), IsError(QUIC_PUBLIC_RESET));
-  } else {
-    // The connection should be unaffected.
-    SendSynchronousFooRequestAndCheckResponse();
-  }
+  // The request should fail. IETF stateless reset does not include connection
+  // ID.
+  EXPECT_EQ("", client_->SendSynchronousRequest("/foo"));
+  EXPECT_TRUE(client_->response_headers()->empty());
+  EXPECT_THAT(client_->connection_error(), IsError(QUIC_PUBLIC_RESET));
 
   client_connection->set_debug_visitor(nullptr);
 }
@@ -4179,8 +4107,7 @@
       TestConnectionIdToUInt64(client_connection->connection_id()) + 1);
   std::unique_ptr<QuicEncryptedPacket> packet(
       QuicFramer::BuildVersionNegotiationPacket(
-          incorrect_connection_id, EmptyQuicConnectionId(),
-          version_.HasIetfInvariantHeader(),
+          incorrect_connection_id, EmptyQuicConnectionId(), /*ietf_quic=*/true,
           version_.HasLengthPrefixedConnectionIds(),
           server_supported_versions_));
   NiceMock<MockQuicConnectionDebugVisitor> visitor;
@@ -4255,9 +4182,8 @@
     // Send a version negotiation packet.
     std::unique_ptr<QuicEncryptedPacket> packet(
         QuicFramer::BuildVersionNegotiationPacket(
-            destination_connection_id, source_connection_id,
-            parsed_version.HasIetfInvariantHeader(), has_length_prefix,
-            supported_versions_));
+            destination_connection_id, source_connection_id, /*ietf_quic=*/true,
+            has_length_prefix, supported_versions_));
     server_writer_->WritePacket(
         packet->data(), packet->length(), peer_address.host(),
         client_->client()->network_helper()->GetLatestClientAddress(), nullptr);
@@ -4834,49 +4760,6 @@
   VerifyCleanConnection(true);
 }
 
-// Regression test for b/111515567
-TEST_P(EndToEndTest, AgreeOnStopWaiting) {
-  ASSERT_TRUE(Initialize());
-  EXPECT_TRUE(client_->client()->WaitForOneRttKeysAvailable());
-
-  QuicConnection* client_connection = GetClientConnection();
-  ASSERT_TRUE(client_connection);
-  server_thread_->Pause();
-  QuicConnection* server_connection = GetServerConnection();
-  if (server_connection != nullptr) {
-    // Verify client and server connections agree on the value of
-    // no_stop_waiting_frames.
-    EXPECT_EQ(QuicConnectionPeer::GetNoStopWaitingFrames(client_connection),
-              QuicConnectionPeer::GetNoStopWaitingFrames(server_connection));
-  } else {
-    ADD_FAILURE() << "Missing server connection";
-  }
-  server_thread_->Resume();
-}
-
-// Regression test for b/111515567
-TEST_P(EndToEndTest, AgreeOnStopWaitingWithNoStopWaitingOption) {
-  QuicTagVector options;
-  options.push_back(kNSTP);
-  client_config_.SetConnectionOptionsToSend(options);
-  ASSERT_TRUE(Initialize());
-  EXPECT_TRUE(client_->client()->WaitForOneRttKeysAvailable());
-
-  QuicConnection* client_connection = GetClientConnection();
-  ASSERT_TRUE(client_connection);
-  server_thread_->Pause();
-  QuicConnection* server_connection = GetServerConnection();
-  if (server_connection != nullptr) {
-    // Verify client and server connections agree on the value of
-    // no_stop_waiting_frames.
-    EXPECT_EQ(QuicConnectionPeer::GetNoStopWaitingFrames(client_connection),
-              QuicConnectionPeer::GetNoStopWaitingFrames(server_connection));
-  } else {
-    ADD_FAILURE() << "Missing server connection";
-  }
-  server_thread_->Resume();
-}
-
 TEST_P(EndToEndTest, ReleaseHeadersStreamBufferWhenIdle) {
   // Tests that when client side has no active request and no waiting
   // PUSH_PROMISE, its headers stream's sequencer buffer should be released.
@@ -5243,10 +5126,6 @@
 }
 
 TEST_P(EndToEndTest, SendMessages) {
-  if (!version_.SupportsMessageFrames()) {
-    Initialize();
-    return;
-  }
   ASSERT_TRUE(Initialize());
   EXPECT_TRUE(client_->client()->WaitForOneRttKeysAvailable());
   QuicSession* client_session = GetClientSession();
@@ -6001,11 +5880,6 @@
 };
 
 TEST_P(EndToEndTest, ConnectionCloseBeforeHandshakeComplete) {
-  if (!version_.HasIetfInvariantHeader()) {
-    // Only runs for IETF QUIC header.
-    Initialize();
-    return;
-  }
   // This test ensures ZERO_RTT_PROTECTED connection close could close a client
   // which has switched to forward secure.
   connect_to_server_on_initialize_ = false;
@@ -6076,12 +5950,8 @@
 TEST_P(EndToEndTest, ForwardSecureConnectionClose) {
   // This test ensures ZERO_RTT_PROTECTED connection close is sent to a client
   // which has ZERO_RTT_PROTECTED encryption level.
-  connect_to_server_on_initialize_ = !version_.HasIetfInvariantHeader();
+  connect_to_server_on_initialize_ = false;
   ASSERT_TRUE(Initialize());
-  if (!version_.HasIetfInvariantHeader()) {
-    // Only runs for IETF QUIC header.
-    return;
-  }
   server_thread_->Pause();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
diff --git a/quiche/quic/core/http/quic_spdy_client_session_test.cc b/quiche/quic/core/http/quic_spdy_client_session_test.cc
index 2696f19..11df4a3 100644
--- a/quiche/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quiche/quic/core/http/quic_spdy_client_session_test.cc
@@ -569,16 +569,11 @@
   // Verify that a decryptable packet with bad frames does close the connection.
   QuicConnectionId destination_connection_id =
       session_->connection()->connection_id();
-  QuicConnectionId source_connection_id = EmptyQuicConnectionId();
+  QuicConnectionId source_connection_id = destination_connection_id;
   QuicFramerPeer::SetLastSerializedServerConnectionId(
       QuicConnectionPeer::GetFramer(connection_), destination_connection_id);
-  bool version_flag = false;
-  QuicConnectionIdIncluded scid_included = CONNECTION_ID_ABSENT;
-  if (version.HasIetfInvariantHeader()) {
-    version_flag = true;
-    source_connection_id = destination_connection_id;
-    scid_included = CONNECTION_ID_PRESENT;
-  }
+  bool version_flag = true;
+  QuicConnectionIdIncluded scid_included = CONNECTION_ID_PRESENT;
   std::unique_ptr<QuicEncryptedPacket> packet(ConstructMisFramedEncryptedPacket(
       destination_connection_id, source_connection_id, version_flag, false, 100,
       "data", CONNECTION_ID_ABSENT, scid_included, PACKET_4BYTE_PACKET_NUMBER,
diff --git a/quiche/quic/core/quic_connection.cc b/quiche/quic/core/quic_connection.cc
index adb6e87..3e575f2 100644
--- a/quiche/quic/core/quic_connection.cc
+++ b/quiche/quic/core/quic_connection.cc
@@ -292,7 +292,6 @@
           ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET),
       num_rtos_for_blackhole_detection_(0),
       uber_received_packet_manager_(&stats_),
-      stop_waiting_count_(0),
       pending_retransmission_alarm_(false),
       defer_send_in_response_to_packets_(false),
       arena_(),
@@ -328,7 +327,6 @@
       peer_max_packet_size_(kDefaultMaxPacketSizeTransportParam),
       largest_received_packet_size_(0),
       write_error_occurred_(false),
-      no_stop_waiting_frames_(version().HasIetfInvariantHeader()),
       consecutive_num_packets_with_no_retransmittable_frames_(0),
       max_consecutive_num_packets_with_no_retransmittable_frames_(
           kMaxConsecutiveNonRetransmittablePackets),
@@ -627,9 +625,6 @@
       config.HasClientSentConnectionOption(k8PTO, perspective_)) {
     num_rtos_for_blackhole_detection_ = 5;
   }
-  if (config.HasClientSentConnectionOption(kNSTP, perspective_)) {
-    no_stop_waiting_frames_ = true;
-  }
   if (config.HasReceivedStatelessResetToken()) {
     default_path_.stateless_reset_token = config.ReceivedStatelessResetToken();
   }
@@ -829,26 +824,6 @@
   last_received_packet_info_.decrypted = false;
 }
 
-void QuicConnection::OnPublicResetPacket(const QuicPublicResetPacket& packet) {
-  // Check that any public reset packet with a different connection ID that was
-  // routed to this QuicConnection has been redirected before control reaches
-  // here.  (Check for a bug regression.)
-  QUICHE_DCHECK_EQ(default_path_.server_connection_id, packet.connection_id);
-  QUICHE_DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
-  QUICHE_DCHECK(!version().HasIetfInvariantHeader());
-  if (debug_visitor_ != nullptr) {
-    debug_visitor_->OnPublicResetPacket(packet);
-  }
-  std::string error_details = "Received public reset.";
-  if (perspective_ == Perspective::IS_CLIENT && !packet.endpoint_id.empty()) {
-    absl::StrAppend(&error_details, " From ", packet.endpoint_id, ".");
-  }
-  QUIC_DLOG(INFO) << ENDPOINT << error_details;
-  QUIC_CODE_COUNT(quic_tear_down_local_connection_on_public_reset);
-  TearDownLocalConnectionState(QUIC_PUBLIC_RESET, NO_IETF_QUIC_ERROR,
-                               error_details, ConnectionCloseSource::FROM_PEER);
-}
-
 bool QuicConnection::OnProtocolVersionMismatch(
     ParsedQuicVersion received_version) {
   QUIC_DLOG(INFO) << ENDPOINT << "Received packet with mismatched version "
@@ -1578,21 +1553,12 @@
   }
   SetLargestReceivedPacketWithAck(
       last_received_packet_info_.header.packet_number);
-  // If the incoming ack's packets set expresses missing packets: peer is still
-  // waiting for a packet lower than a packet that we are no longer planning to
-  // send.
-  // If the incoming ack's packets set expresses received packets: peer is still
-  // acking packets which we never care about.
-  // Send an ack to raise the high water mark.
-  const bool send_stop_waiting =
-      no_stop_waiting_frames_ ? false : GetLeastUnacked() > start;
-  PostProcessAfterAckFrame(send_stop_waiting,
-                           ack_result == PACKETS_NEWLY_ACKED);
+  PostProcessAfterAckFrame(ack_result == PACKETS_NEWLY_ACKED);
   processing_ack_frame_ = false;
   return connected_;
 }
 
-bool QuicConnection::OnStopWaitingFrame(const QuicStopWaitingFrame& frame) {
+bool QuicConnection::OnStopWaitingFrame(const QuicStopWaitingFrame& /*frame*/) {
   QUIC_BUG_IF(quic_bug_12714_8, !connected_)
       << "Processing STOP_WAITING frame when connection is closed. Received "
          "packet info: "
@@ -1603,33 +1569,6 @@
   if (!UpdatePacketContent(STOP_WAITING_FRAME)) {
     return false;
   }
-
-  if (no_stop_waiting_frames_) {
-    return true;
-  }
-  if (largest_seen_packet_with_stop_waiting_.IsInitialized() &&
-      last_received_packet_info_.header.packet_number <=
-          largest_seen_packet_with_stop_waiting_) {
-    QUIC_DLOG(INFO) << ENDPOINT
-                    << "Received an old stop waiting frame: ignoring";
-    return true;
-  }
-
-  const char* error = ValidateStopWaitingFrame(frame);
-  if (error != nullptr) {
-    CloseConnection(QUIC_INVALID_STOP_WAITING_DATA, error,
-                    ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-    return false;
-  }
-
-  if (debug_visitor_ != nullptr) {
-    debug_visitor_->OnStopWaitingFrame(frame);
-  }
-
-  largest_seen_packet_with_stop_waiting_ =
-      last_received_packet_info_.header.packet_number;
-  uber_received_packet_manager_.DontWaitForPacketsBefore(
-      last_received_packet_info_.decrypted_level, frame.least_unacked);
   return connected_;
 }
 
@@ -1669,31 +1608,6 @@
   return true;
 }
 
-const char* QuicConnection::ValidateStopWaitingFrame(
-    const QuicStopWaitingFrame& stop_waiting) {
-  const QuicPacketNumber peer_least_packet_awaiting_ack =
-      uber_received_packet_manager_.peer_least_packet_awaiting_ack();
-  if (peer_least_packet_awaiting_ack.IsInitialized() &&
-      stop_waiting.least_unacked < peer_least_packet_awaiting_ack) {
-    QUIC_DLOG(ERROR) << ENDPOINT << "Peer's sent low least_unacked: "
-                     << stop_waiting.least_unacked << " vs "
-                     << peer_least_packet_awaiting_ack;
-    // We never process old ack frames, so this number should only increase.
-    return "Least unacked too small.";
-  }
-
-  if (stop_waiting.least_unacked >
-      last_received_packet_info_.header.packet_number) {
-    QUIC_DLOG(ERROR) << ENDPOINT
-                     << "Peer sent least_unacked:" << stop_waiting.least_unacked
-                     << " greater than the enclosing packet number:"
-                     << last_received_packet_info_.header.packet_number;
-    return "Least unacked too large.";
-  }
-
-  return nullptr;
-}
-
 bool QuicConnection::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
   QUIC_BUG_IF(quic_bug_12714_11, !connected_)
       << "Processing RST_STREAM frame when connection is closed. Received "
@@ -2334,7 +2248,6 @@
     const QuicIetfStatelessResetPacket& /*packet*/) {
   // TODO(fayang): Add OnAuthenticatedIetfStatelessResetPacket to
   // debug_visitor_.
-  QUICHE_DCHECK(version().HasIetfInvariantHeader());
   QUICHE_DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
 
   if (!IsDefaultPath(last_received_packet_info_.destination_address,
@@ -2433,11 +2346,6 @@
       clock_->ApproximateNow());
 }
 
-void QuicConnection::PopulateStopWaitingFrame(
-    QuicStopWaitingFrame* stop_waiting) {
-  stop_waiting->least_unacked = GetLeastUnacked();
-}
-
 QuicPacketNumber QuicConnection::GetLeastUnacked() const {
   return sent_packet_manager_.GetLeastUnacked();
 }
@@ -3083,13 +2991,6 @@
   if (!version_negotiated_) {
     if (perspective_ == Perspective::IS_CLIENT) {
       QUICHE_DCHECK(!header.version_flag || header.form != GOOGLE_QUIC_PACKET);
-      if (!version().HasIetfInvariantHeader()) {
-        // If the client gets a packet without the version flag from the server
-        // it should stop sending version since the version negotiation is done.
-        // IETF QUIC stops sending version once encryption level switches to
-        // forward secure.
-        packet_creator_.StopSendingVersion();
-      }
       version_negotiated_ = true;
       OnSuccessfulVersionNegotiation();
     }
@@ -3244,7 +3145,7 @@
       uber_received_packet_manager_
           .GetAckTimeout(QuicUtils::GetPacketNumberSpace(encryption_level_))
           .IsInitialized();
-  if (!has_pending_ack && stop_waiting_count_ <= 1) {
+  if (!has_pending_ack) {
     // No need to send an ACK.
     return frames;
   }
@@ -3255,14 +3156,8 @@
   QUIC_BUG_IF(quic_bug_12714_23, updated_ack_frame.ack_frame->packets.Empty())
       << ENDPOINT << "Attempted to opportunistically bundle an empty "
       << encryption_level_ << " ACK, " << (has_pending_ack ? "" : "!")
-      << "has_pending_ack, stop_waiting_count_ " << stop_waiting_count_;
+      << "has_pending_ack";
   frames.push_back(updated_ack_frame);
-
-  if (!no_stop_waiting_frames_) {
-    QuicStopWaitingFrame stop_waiting;
-    PopulateStopWaitingFrame(&stop_waiting);
-    frames.push_back(QuicFrame(stop_waiting));
-  }
   return frames;
 }
 
@@ -3938,11 +3833,7 @@
     return;
   }
   // We can't send an error as the socket is presumably borked.
-  if (version().HasIetfInvariantHeader()) {
-    QUIC_CODE_COUNT(quic_tear_down_local_connection_on_write_error_ietf);
-  } else {
-    QUIC_CODE_COUNT(quic_tear_down_local_connection_on_write_error_non_ietf);
-  }
+  QUIC_CODE_COUNT(quic_tear_down_local_connection_on_write_error_ietf);
   CloseConnection(QUIC_PACKET_WRITE_ERROR, error_details,
                   ConnectionCloseBehavior::SILENT_CLOSE);
 }
@@ -3963,13 +3854,7 @@
     // loop here.
     // TODO(ianswett): This is actually an internal error, not an
     // encryption failure.
-    if (version().HasIetfInvariantHeader()) {
-      QUIC_CODE_COUNT(
-          quic_tear_down_local_connection_on_serialized_packet_ietf);
-    } else {
-      QUIC_CODE_COUNT(
-          quic_tear_down_local_connection_on_serialized_packet_non_ietf);
-    }
+    QUIC_CODE_COUNT(quic_tear_down_local_connection_on_serialized_packet_ietf);
     CloseConnection(QUIC_ENCRYPTION_FAILURE,
                     "Serialized packet does not have an encrypted buffer.",
                     ConnectionCloseBehavior::SILENT_CLOSE);
@@ -3997,13 +3882,7 @@
                                           const std::string& error_details) {
   // The packet creator or generator encountered an unrecoverable error: tear
   // down local connection state immediately.
-  if (version().HasIetfInvariantHeader()) {
-    QUIC_CODE_COUNT(
-        quic_tear_down_local_connection_on_unrecoverable_error_ietf);
-  } else {
-    QUIC_CODE_COUNT(
-        quic_tear_down_local_connection_on_unrecoverable_error_non_ietf);
-  }
+  QUIC_CODE_COUNT(quic_tear_down_local_connection_on_unrecoverable_error_ietf);
   CloseConnection(error, error_details, ConnectionCloseBehavior::SILENT_CLOSE);
 }
 
@@ -4152,11 +4031,6 @@
   QUIC_DVLOG(1) << ENDPOINT << "Sending an ACK proactively";
   QuicFrames frames;
   frames.push_back(GetUpdatedAckFrame());
-  if (!no_stop_waiting_frames_) {
-    QuicStopWaitingFrame stop_waiting;
-    PopulateStopWaitingFrame(&stop_waiting);
-    frames.push_back(QuicFrame(stop_waiting));
-  }
   if (!packet_creator_.FlushAckFrame(frames)) {
     return;
   }
@@ -5750,9 +5624,8 @@
   current_effective_peer_migration_type_ = NO_CHANGE;
 }
 
-void QuicConnection::PostProcessAfterAckFrame(bool send_stop_waiting,
-                                              bool acked_new_packet) {
-  if (no_stop_waiting_frames_ && !packet_creator_.has_ack()) {
+void QuicConnection::PostProcessAfterAckFrame(bool acked_new_packet) {
+  if (!packet_creator_.has_ack()) {
     uber_received_packet_manager_.DontWaitForPacketsBefore(
         last_received_packet_info_.decrypted_level,
         SupportsMultiplePacketNumberSpaces()
@@ -5773,12 +5646,6 @@
     // detection if there is no packets in flight.
     blackhole_detector_.StopDetection(/*permanent=*/false);
   }
-
-  if (send_stop_waiting) {
-    ++stop_waiting_count_;
-  } else {
-    stop_waiting_count_ = 0;
-  }
 }
 
 void QuicConnection::SetSessionNotifier(
@@ -5812,18 +5679,12 @@
 
 void QuicConnection::ResetAckStates() {
   ack_alarm_->Cancel();
-  stop_waiting_count_ = 0;
   uber_received_packet_manager_.ResetAckStates(encryption_level_);
 }
 
 MessageStatus QuicConnection::SendMessage(
     QuicMessageId message_id, absl::Span<quiche::QuicheMemSlice> message,
     bool flush) {
-  if (!VersionSupportsMessageFrames(transport_version())) {
-    QUIC_BUG(quic_bug_10511_38)
-        << "MESSAGE frame is not supported for version " << transport_version();
-    return MESSAGE_STATUS_UNSUPPORTED;
-  }
   if (MemSliceSpanTotalSize(message) > GetCurrentLargestMessagePayload()) {
     return MESSAGE_STATUS_TOO_LARGE;
   }
@@ -5864,11 +5725,7 @@
   }
   if (framer_.HasEncrypterOfEncryptionLevel(ENCRYPTION_ZERO_RTT)) {
     if (encryption_level_ != ENCRYPTION_ZERO_RTT) {
-      if (version().HasIetfInvariantHeader()) {
-        QUIC_CODE_COUNT(quic_wrong_encryption_level_connection_close_ietf);
-      } else {
-        QUIC_CODE_COUNT(quic_wrong_encryption_level_connection_close);
-      }
+      QUIC_CODE_COUNT(quic_wrong_encryption_level_connection_close_ietf);
     }
     return ENCRYPTION_ZERO_RTT;
   }
diff --git a/quiche/quic/core/quic_connection.h b/quiche/quic/core/quic_connection.h
index f739644..8274be2 100644
--- a/quiche/quic/core/quic_connection.h
+++ b/quiche/quic/core/quic_connection.h
@@ -331,9 +331,6 @@
   // Called when a CRYPTO frame containing handshake data is received.
   virtual void OnCryptoFrame(const QuicCryptoFrame& /*frame*/) {}
 
-  // Called when a StopWaitingFrame has been parsed.
-  virtual void OnStopWaitingFrame(const QuicStopWaitingFrame& /*frame*/) {}
-
   // Called when a QuicPaddingFrame has been parsed.
   virtual void OnPaddingFrame(const QuicPaddingFrame& /*frame*/) {}
 
@@ -377,9 +374,6 @@
   // Called when a HandshakeDoneFrame has been parsed.
   virtual void OnHandshakeDoneFrame(const QuicHandshakeDoneFrame& /*frame*/) {}
 
-  // Called when a public reset packet has been received.
-  virtual void OnPublicResetPacket(const QuicPublicResetPacket& /*packet*/) {}
-
   // Called when a version negotiation packet has been received.
   virtual void OnVersionNegotiationPacket(
       const QuicVersionNegotiationPacket& /*packet*/) {}
@@ -669,7 +663,6 @@
   void OnError(QuicFramer* framer) override;
   bool OnProtocolVersionMismatch(ParsedQuicVersion received_version) override;
   void OnPacket() override;
-  void OnPublicResetPacket(const QuicPublicResetPacket& packet) override;
   void OnVersionNegotiationPacket(
       const QuicVersionNegotiationPacket& packet) override;
   void OnRetryPacket(QuicConnectionId original_connection_id,
@@ -1648,11 +1641,11 @@
 
   // Notifies the visitor of the close and marks the connection as disconnected.
   // Does not send a connection close frame to the peer. It should only be
-  // called by CloseConnection or OnConnectionCloseFrame, OnPublicResetPacket,
-  // and OnAuthenticatedIetfStatelessResetPacket.
-  // |ietf_error| may optionally be be used to directly specify the wire
-  // error code. Otherwise if |ietf_error| is NO_IETF_QUIC_ERROR, the
-  // QuicErrorCodeToTransportErrorCode mapping of |error| will be used.
+  // called by CloseConnection or OnConnectionCloseFrame, and
+  // OnAuthenticatedIetfStatelessResetPacket. |ietf_error| may optionally be be
+  // used to directly specify the wire error code. Otherwise if |ietf_error| is
+  // NO_IETF_QUIC_ERROR, the QuicErrorCodeToTransportErrorCode mapping of
+  // |error| will be used.
   void TearDownLocalConnectionState(QuicErrorCode error,
                                     QuicIetfTransportErrorCodes ietf_error,
                                     const std::string& details,
@@ -1721,11 +1714,6 @@
   // Flush packets buffered in the writer, if any.
   void FlushPackets();
 
-  // Make sure a stop waiting we got from our peer is sane.
-  // Returns nullptr if the frame is valid or an error string if it was invalid.
-  const char* ValidateStopWaitingFrame(
-      const QuicStopWaitingFrame& stop_waiting);
-
   // Clears any accumulated frames from the last received packet.
   void ClearLastFrames();
 
@@ -1799,9 +1787,8 @@
   ABSL_MUST_USE_RESULT bool UpdatePacketContent(QuicFrameType type);
 
   // Called when last received ack frame has been processed.
-  // |send_stop_waiting| indicates whether a stop waiting needs to be sent.
   // |acked_new_packet| is true if a previously-unacked packet was acked.
-  void PostProcessAfterAckFrame(bool send_stop_waiting, bool acked_new_packet);
+  void PostProcessAfterAckFrame(bool acked_new_packet);
 
   // Updates the release time into the future.
   void UpdateReleaseTimeIntoFuture();
@@ -1819,8 +1806,6 @@
   // Returns true if the ACK frame should be bundled with ACK-eliciting frame.
   bool ShouldBundleRetransmittableFrameWithAck() const;
 
-  void PopulateStopWaitingFrame(QuicStopWaitingFrame* stop_waiting);
-
   // Enables multiple packet number spaces support based on handshake protocol
   // and flags.
   void MaybeEnableMultiplePacketNumberSpacesSupport();
@@ -2142,11 +2127,6 @@
 
   UberReceivedPacketManager uber_received_packet_manager_;
 
-  // Indicates how many consecutive times an ack has arrived which indicates
-  // the peer needs to stop waiting for some packets.
-  // TODO(fayang): remove this when deprecating Q043.
-  int stop_waiting_count_;
-
   // Indicates the retransmission alarm needs to be set.
   bool pending_retransmission_alarm_;
 
@@ -2240,9 +2220,6 @@
   // avoid infinite write errors.
   bool write_error_occurred_;
 
-  // Indicates not to send or process stop waiting frames.
-  bool no_stop_waiting_frames_;
-
   // Consecutive number of sent packets which have no retransmittable frames.
   size_t consecutive_num_packets_with_no_retransmittable_frames_;
 
diff --git a/quiche/quic/core/quic_connection_test.cc b/quiche/quic/core/quic_connection_test.cc
index 88a9fd4..5db68ba 100644
--- a/quiche/quic/core/quic_connection_test.cc
+++ b/quiche/quic/core/quic_connection_test.cc
@@ -562,23 +562,18 @@
 
 // Run tests with combinations of {ParsedQuicVersion, AckResponse}.
 struct TestParams {
-  TestParams(ParsedQuicVersion version, AckResponse ack_response,
-             bool no_stop_waiting)
-      : version(version),
-        ack_response(ack_response),
-        no_stop_waiting(no_stop_waiting) {}
+  TestParams(ParsedQuicVersion version, AckResponse ack_response)
+      : version(version), ack_response(ack_response) {}
 
   ParsedQuicVersion version;
   AckResponse ack_response;
-  bool no_stop_waiting;
 };
 
 // Used by ::testing::PrintToStringParamName().
 std::string PrintToString(const TestParams& p) {
   return absl::StrCat(
       ParsedQuicVersionToString(p.version), "_",
-      (p.ack_response == AckResponse::kDefer ? "defer" : "immediate"), "_",
-      (p.no_stop_waiting ? "No" : ""), "StopWaiting");
+      (p.ack_response == AckResponse::kDefer ? "defer" : "immediate"));
 }
 
 // Constructs various test permutations.
@@ -589,12 +584,7 @@
   for (size_t i = 0; i < all_supported_versions.size(); ++i) {
     for (AckResponse ack_response :
          {AckResponse::kDefer, AckResponse::kImmediate}) {
-      params.push_back(
-          TestParams(all_supported_versions[i], ack_response, true));
-      if (!all_supported_versions[i].HasIetfInvariantHeader()) {
-        params.push_back(
-            TestParams(all_supported_versions[i], ack_response, false));
-      }
+      params.push_back(TestParams(all_supported_versions[i], ack_response));
     }
   }
   return params;
@@ -665,12 +655,6 @@
         QuicConnectionPeer::GetFramer(&connection_), connection_id_);
     QuicFramerPeer::SetLastWrittenPacketNumberLength(
         QuicConnectionPeer::GetFramer(&connection_), packet_number_length_);
-    if (version().HasIetfInvariantHeader()) {
-      EXPECT_TRUE(QuicConnectionPeer::GetNoStopWaitingFrames(&connection_));
-    } else {
-      QuicConnectionPeer::SetNoStopWaitingFrames(&connection_,
-                                                 GetParam().no_stop_waiting);
-    }
     QuicStreamId stream_id;
     if (QuicVersionUsesCryptoFrames(version().transport_version)) {
       stream_id = QuicUtils::GetFirstBidirectionalStreamId(
@@ -740,18 +724,6 @@
 
   ParsedQuicVersion version() { return GetParam().version; }
 
-  QuicStopWaitingFrame* stop_waiting() {
-    QuicConnectionPeer::PopulateStopWaitingFrame(&connection_, &stop_waiting_);
-    return &stop_waiting_;
-  }
-
-  QuicPacketNumber least_unacked() {
-    if (writer_->stop_waiting_frames().empty()) {
-      return QuicPacketNumber();
-    }
-    return writer_->stop_waiting_frames()[0].least_unacked;
-  }
-
   void SetClientConnectionId(const QuicConnectionId& client_connection_id) {
     connection_.set_client_connection_id(client_connection_id);
     writer_->framer()->framer()->SetExpectedClientConnectionIdLength(
@@ -1152,8 +1124,7 @@
   QuicPacketHeader ConstructPacketHeader(uint64_t number,
                                          EncryptionLevel level) {
     QuicPacketHeader header;
-    if (peer_framer_.version().HasIetfInvariantHeader() &&
-        level < ENCRYPTION_FORWARD_SECURE) {
+    if (level < ENCRYPTION_FORWARD_SECURE) {
       // Set long header type accordingly.
       header.version_flag = true;
       header.form = IETF_QUIC_LONG_HEADER_PACKET;
@@ -1177,8 +1148,7 @@
       header.destination_connection_id = connection_id_;
       header.destination_connection_id_included = connection_id_included_;
     }
-    if (peer_framer_.version().HasIetfInvariantHeader() &&
-        peer_framer_.perspective() == Perspective::IS_SERVER) {
+    if (peer_framer_.perspective() == Perspective::IS_SERVER) {
       if (!connection_.client_connection_id().IsEmpty()) {
         header.destination_connection_id = connection_.client_connection_id();
         header.destination_connection_id_included = CONNECTION_ID_PRESENT;
@@ -1194,12 +1164,6 @@
         }
       }
     }
-    if (!peer_framer_.version().HasIetfInvariantHeader() &&
-        peer_framer_.perspective() == Perspective::IS_SERVER &&
-        GetParam().version.handshake_protocol == PROTOCOL_QUIC_CRYPTO &&
-        level == ENCRYPTION_ZERO_RTT) {
-      header.nonce = &kTestDiversificationNonce;
-    }
     header.packet_number_length = packet_number_length_;
     header.packet_number = QuicPacketNumber(number);
     return header;
@@ -1244,14 +1208,9 @@
     if (peer_framer_.perspective() == Perspective::IS_SERVER) {
       header.source_connection_id = connection_id_;
       header.destination_connection_id_included = CONNECTION_ID_ABSENT;
-      if (!peer_framer_.version().HasIetfInvariantHeader()) {
-        header.source_connection_id_included = CONNECTION_ID_PRESENT;
-      }
     } else {
       header.destination_connection_id = connection_id_;
-      if (peer_framer_.version().HasIetfInvariantHeader()) {
-        header.destination_connection_id_included = CONNECTION_ID_ABSENT;
-      }
+      header.destination_connection_id_included = CONNECTION_ID_ABSENT;
     }
 
     header.packet_number = QuicPacketNumber(number);
@@ -1375,7 +1334,7 @@
   bool IsDefaultTestConfiguration() {
     TestParams p = GetParam();
     return p.ack_response == AckResponse::kImmediate &&
-           p.version == AllSupportedVersions()[0] && p.no_stop_waiting;
+           p.version == AllSupportedVersions()[0];
   }
 
   void TestConnectionCloseQuicErrorCode(QuicErrorCode expected_code) {
@@ -3488,12 +3447,7 @@
   QuicPacketNumber retransmission;
   // Packet 1 is short header for IETF QUIC because the encryption level
   // switched to ENCRYPTION_FORWARD_SECURE in SendStreamDataToPeer.
-  EXPECT_CALL(*send_algorithm_,
-              OnPacketSent(_, _, _,
-                           GetParam().version.HasIetfInvariantHeader()
-                               ? packet_size
-                               : packet_size - kQuicVersionSize,
-                           _))
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, packet_size, _))
       .WillOnce(SaveArg<2>(&retransmission));
 
   ProcessAckPacket(&frame);
@@ -3522,18 +3476,10 @@
               OnPacketSent(_, _, _, _, HAS_RETRANSMITTABLE_DATA));
   connection_.SendStreamDataWithString(3, "foofoofoo", 9, NO_FIN);
   // Ack bundled.
-  if (GetParam().no_stop_waiting) {
-    // Do not ACK acks.
-    EXPECT_EQ(1u, writer_->frame_count());
-  } else {
-    EXPECT_EQ(3u, writer_->frame_count());
-  }
+  // Do not ACK acks.
+  EXPECT_EQ(1u, writer_->frame_count());
   EXPECT_EQ(1u, writer_->stream_frames().size());
-  if (GetParam().no_stop_waiting) {
-    EXPECT_TRUE(writer_->ack_frames().empty());
-  } else {
-    EXPECT_FALSE(writer_->ack_frames().empty());
-  }
+  EXPECT_TRUE(writer_->ack_frames().empty());
 
   // But an ack with no missing packets will not send an ack.
   AckPacket(original, &frame2);
@@ -3680,46 +3626,6 @@
   EXPECT_EQ(1u, writer_->window_update_frames().size());
 }
 
-TEST_P(QuicConnectionTest, LeastUnackedLower) {
-  if (GetParam().version.HasIetfInvariantHeader()) {
-    return;
-  }
-  EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-
-  SendStreamDataToPeer(1, "foo", 0, NO_FIN, nullptr);
-  SendStreamDataToPeer(1, "bar", 3, NO_FIN, nullptr);
-  SendStreamDataToPeer(1, "eep", 6, NO_FIN, nullptr);
-
-  // Start out saying the least unacked is 2.
-  QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 5);
-  ProcessStopWaitingPacket(InitStopWaitingFrame(2));
-
-  // Change it to 1, but lower the packet number to fake out-of-order packets.
-  // This should be fine.
-  QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 1);
-  // The scheduler will not process out of order acks, but all packet processing
-  // causes the connection to try to write.
-  if (!GetParam().no_stop_waiting) {
-    EXPECT_CALL(visitor_, OnCanWrite());
-  }
-  ProcessStopWaitingPacket(InitStopWaitingFrame(1));
-
-  // Now claim it's one, but set the ordering so it was sent "after" the first
-  // one.  This should cause a connection error.
-  QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 7);
-  if (!GetParam().no_stop_waiting) {
-    EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
-        .Times(AtLeast(1));
-    EXPECT_CALL(visitor_,
-                OnConnectionClosed(_, ConnectionCloseSource::FROM_SELF))
-        .Times(AtLeast(1));
-  }
-  ProcessStopWaitingPacket(InitStopWaitingFrame(1));
-  if (!GetParam().no_stop_waiting) {
-    TestConnectionCloseQuicErrorCode(QUIC_INVALID_STOP_WAITING_DATA);
-  }
-}
-
 TEST_P(QuicConnectionTest, TooManySentPackets) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
@@ -3785,30 +3691,11 @@
   EXPECT_EQ(QuicPacketNumber(1u), last_packet);
   SendAckPacketToPeer();  // Packet 2
 
-  if (GetParam().no_stop_waiting) {
-    // Expect no stop waiting frame is sent.
-    EXPECT_FALSE(least_unacked().IsInitialized());
-  } else {
-    EXPECT_EQ(QuicPacketNumber(1u), least_unacked());
-  }
-
   SendAckPacketToPeer();  // Packet 3
-  if (GetParam().no_stop_waiting) {
-    // Expect no stop waiting frame is sent.
-    EXPECT_FALSE(least_unacked().IsInitialized());
-  } else {
-    EXPECT_EQ(QuicPacketNumber(1u), least_unacked());
-  }
 
   SendStreamDataToPeer(1, "bar", 3, NO_FIN, &last_packet);  // Packet 4
   EXPECT_EQ(QuicPacketNumber(4u), last_packet);
   SendAckPacketToPeer();  // Packet 5
-  if (GetParam().no_stop_waiting) {
-    // Expect no stop waiting frame is sent.
-    EXPECT_FALSE(least_unacked().IsInitialized());
-  } else {
-    EXPECT_EQ(QuicPacketNumber(1u), least_unacked());
-  }
 
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _, _, _));
 
@@ -3817,15 +3704,6 @@
   ProcessAckPacket(&frame);
   SendAckPacketToPeer();  // Packet 6
 
-  // As soon as we've acked one, we skip ack packets 2 and 3 and note lack of
-  // ack for 4.
-  if (GetParam().no_stop_waiting) {
-    // Expect no stop waiting frame is sent.
-    EXPECT_FALSE(least_unacked().IsInitialized());
-  } else {
-    EXPECT_EQ(QuicPacketNumber(4u), least_unacked());
-  }
-
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _, _, _));
 
   // Peer acks up to packet 4, the last packet.
@@ -3835,33 +3713,13 @@
   // Verify that we did not send an ack.
   EXPECT_EQ(QuicPacketNumber(6u), writer_->header().packet_number);
 
-  // So the last ack has not changed.
-  if (GetParam().no_stop_waiting) {
-    // Expect no stop waiting frame is sent.
-    EXPECT_FALSE(least_unacked().IsInitialized());
-  } else {
-    EXPECT_EQ(QuicPacketNumber(4u), least_unacked());
-  }
-
   // If we force an ack, we shouldn't change our retransmit state.
   SendAckPacketToPeer();  // Packet 7
-  if (GetParam().no_stop_waiting) {
-    // Expect no stop waiting frame is sent.
-    EXPECT_FALSE(least_unacked().IsInitialized());
-  } else {
-    EXPECT_EQ(QuicPacketNumber(7u), least_unacked());
-  }
 
   // But if we send more data it should.
   SendStreamDataToPeer(1, "eep", 6, NO_FIN, &last_packet);  // Packet 8
   EXPECT_EQ(QuicPacketNumber(8u), last_packet);
   SendAckPacketToPeer();  // Packet 9
-  if (GetParam().no_stop_waiting) {
-    // Expect no stop waiting frame is sent.
-    EXPECT_FALSE(least_unacked().IsInitialized());
-  } else {
-    EXPECT_EQ(QuicPacketNumber(7u), least_unacked());
-  }
   EXPECT_EQ(QuicPacketNumber(1), stats.first_decrypted_packet);
 }
 
@@ -3992,13 +3850,8 @@
 
   // Parse the last packet and ensure it's an ack and two stream frames from
   // two different streams.
-  if (GetParam().no_stop_waiting) {
-    EXPECT_EQ(2u, writer_->frame_count());
-    EXPECT_TRUE(writer_->stop_waiting_frames().empty());
-  } else {
-    EXPECT_EQ(2u, writer_->frame_count());
-    EXPECT_TRUE(writer_->stop_waiting_frames().empty());
-  }
+  EXPECT_EQ(2u, writer_->frame_count());
+  EXPECT_TRUE(writer_->stop_waiting_frames().empty());
 
   EXPECT_TRUE(writer_->ack_frames().empty());
 
@@ -4107,13 +3960,8 @@
 
   // Parse the last packet and ensure it's an ack and two stream frames from
   // two different streams.
-  if (GetParam().no_stop_waiting) {
-    EXPECT_EQ(3u, writer_->frame_count());
-    EXPECT_TRUE(writer_->stop_waiting_frames().empty());
-  } else {
-    EXPECT_EQ(4u, writer_->frame_count());
-    EXPECT_FALSE(writer_->stop_waiting_frames().empty());
-  }
+  EXPECT_EQ(3u, writer_->frame_count());
+  EXPECT_TRUE(writer_->stop_waiting_frames().empty());
   EXPECT_FALSE(writer_->ack_frames().empty());
   ASSERT_EQ(2u, writer_->stream_frames().size());
   EXPECT_EQ(GetNthClientInitiatedStreamId(1, connection_.transport_version()),
@@ -4555,12 +4403,7 @@
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _, _, _));
   // Packet 1 is short header for IETF QUIC because the encryption level
   // switched to ENCRYPTION_FORWARD_SECURE in SendStreamDataToPeer.
-  EXPECT_CALL(*send_algorithm_,
-              OnPacketSent(_, _, _,
-                           GetParam().version.HasIetfInvariantHeader()
-                               ? packet_size
-                               : packet_size - kQuicVersionSize,
-                           _));
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, packet_size, _));
   ProcessAckPacket(&frame);
 }
 
@@ -4826,29 +4669,14 @@
   QuicAckFrame frame = InitAckFrame(1);
   ProcessAckPacket(&frame);
 
-  // Verify that our internal state has least-unacked as 2, because we're still
-  // waiting for a potential ack for 2.
-
-  EXPECT_EQ(QuicPacketNumber(2u), stop_waiting()->least_unacked);
-
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _, _, _));
   frame = InitAckFrame(2);
   ProcessAckPacket(&frame);
-  EXPECT_EQ(QuicPacketNumber(3u), stop_waiting()->least_unacked);
 
   // When we send an ack, we make sure our least-unacked makes sense.  In this
   // case since we're not waiting on an ack for 2 and all packets are acked, we
   // set it to 3.
   SendAckPacketToPeer();  // Packet 3
-  // Least_unacked remains at 3 until another ack is received.
-  EXPECT_EQ(QuicPacketNumber(3u), stop_waiting()->least_unacked);
-  if (GetParam().no_stop_waiting) {
-    // Expect no stop waiting frame is sent.
-    EXPECT_FALSE(least_unacked().IsInitialized());
-  } else {
-    // Check that the outgoing ack had its packet number as least_unacked.
-    EXPECT_EQ(QuicPacketNumber(3u), least_unacked());
-  }
 
   // Ack the ack, which updates the rtt and raises the least unacked.
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _, _, _));
@@ -4856,14 +4684,7 @@
   ProcessAckPacket(&frame);
 
   SendStreamDataToPeer(1, "bar", 3, NO_FIN, nullptr);  // Packet 4
-  EXPECT_EQ(QuicPacketNumber(4u), stop_waiting()->least_unacked);
   SendAckPacketToPeer();  // Packet 5
-  if (GetParam().no_stop_waiting) {
-    // Expect no stop waiting frame is sent.
-    EXPECT_FALSE(least_unacked().IsInitialized());
-  } else {
-    EXPECT_EQ(QuicPacketNumber(4u), least_unacked());
-  }
 
   // Send two data packets at the end, and ensure if the last one is acked,
   // the least unacked is raised above the ack packets.
@@ -4874,8 +4695,6 @@
   frame = InitAckFrame({{QuicPacketNumber(1), QuicPacketNumber(5)},
                         {QuicPacketNumber(7), QuicPacketNumber(8)}});
   ProcessAckPacket(&frame);
-
-  EXPECT_EQ(QuicPacketNumber(6u), stop_waiting()->least_unacked);
 }
 
 TEST_P(QuicConnectionTest, SendHandshakeMessages) {
@@ -6319,11 +6138,6 @@
 
 TEST_P(QuicConnectionTest, LoopThroughSendingPacketsWithTruncation) {
   set_perspective(Perspective::IS_SERVER);
-  if (!GetParam().version.HasIetfInvariantHeader()) {
-    // For IETF QUIC, encryption level will be switched to FORWARD_SECURE in
-    // SendStreamDataWithString.
-    QuicPacketCreatorPeer::SetSendVersionInPacket(creator_, false);
-  }
   // Set up a larger payload than will fit in one packet.
   const std::string payload(connection_.max_packet_length(), 'a');
   EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)).Times(AnyNumber());
@@ -6345,16 +6159,9 @@
   EXPECT_EQ(payload.size(),
             connection_.SendStreamDataWithString(3, payload, 1350, NO_FIN)
                 .bytes_consumed);
-  if (connection_.version().HasIetfInvariantHeader()) {
-    // Short header packets sent from server omit connection ID already, and
-    // stream offset size increases from 0 to 2.
-    EXPECT_EQ(non_truncated_packet_size, writer_->last_packet_size() - 2);
-  } else {
-    // Just like above, we save 8 bytes on payload, and 8 on truncation. -2
-    // because stream offset size is 2 instead of 0.
-    EXPECT_EQ(non_truncated_packet_size,
-              writer_->last_packet_size() + 8 * 2 - 2);
-  }
+  // Short header packets sent from server omit connection ID already, and
+  // stream offset size increases from 0 to 2.
+  EXPECT_EQ(non_truncated_packet_size, writer_->last_packet_size() - 2);
 }
 
 TEST_P(QuicConnectionTest, SendDelayedAck) {
@@ -6382,13 +6189,8 @@
   connection_.GetAckAlarm()->Fire();
   // Check that ack is sent and that delayed ack alarm is reset.
   size_t padding_frame_count = writer_->padding_frames().size();
-  if (GetParam().no_stop_waiting) {
-    EXPECT_EQ(padding_frame_count + 1u, writer_->frame_count());
-    EXPECT_TRUE(writer_->stop_waiting_frames().empty());
-  } else {
-    EXPECT_EQ(padding_frame_count + 2u, writer_->frame_count());
-    EXPECT_FALSE(writer_->stop_waiting_frames().empty());
-  }
+  EXPECT_EQ(padding_frame_count + 1u, writer_->frame_count());
+  EXPECT_TRUE(writer_->stop_waiting_frames().empty());
   EXPECT_FALSE(writer_->ack_frames().empty());
   EXPECT_FALSE(connection_.HasPendingAcks());
 }
@@ -6440,13 +6242,8 @@
   }
   // Check that ack is sent and that delayed ack alarm is reset.
   size_t padding_frame_count = writer_->padding_frames().size();
-  if (GetParam().no_stop_waiting) {
-    EXPECT_EQ(padding_frame_count + 1u, writer_->frame_count());
-    EXPECT_TRUE(writer_->stop_waiting_frames().empty());
-  } else {
-    EXPECT_EQ(padding_frame_count + 2u, writer_->frame_count());
-    EXPECT_FALSE(writer_->stop_waiting_frames().empty());
-  }
+  EXPECT_EQ(padding_frame_count + 1u, writer_->frame_count());
+  EXPECT_TRUE(writer_->stop_waiting_frames().empty());
   EXPECT_FALSE(writer_->ack_frames().empty());
   EXPECT_FALSE(connection_.HasPendingAcks());
 }
@@ -6557,13 +6354,8 @@
   }
   // Check that ack is sent and that delayed ack alarm is reset.
   size_t padding_frame_count = writer_->padding_frames().size();
-  if (GetParam().no_stop_waiting) {
-    EXPECT_EQ(padding_frame_count + 1u, writer_->frame_count());
-    EXPECT_TRUE(writer_->stop_waiting_frames().empty());
-  } else {
-    EXPECT_EQ(padding_frame_count + 2u, writer_->frame_count());
-    EXPECT_FALSE(writer_->stop_waiting_frames().empty());
-  }
+  EXPECT_EQ(padding_frame_count + 1u, writer_->frame_count());
+  EXPECT_TRUE(writer_->stop_waiting_frames().empty());
   EXPECT_FALSE(writer_->ack_frames().empty());
   EXPECT_FALSE(connection_.HasPendingAcks());
 }
@@ -6600,13 +6392,8 @@
   ProcessPacket(2);
   // Check that ack is sent and that delayed ack alarm is reset.
   size_t padding_frame_count = writer_->padding_frames().size();
-  if (GetParam().no_stop_waiting) {
-    EXPECT_EQ(padding_frame_count + 1u, writer_->frame_count());
-    EXPECT_TRUE(writer_->stop_waiting_frames().empty());
-  } else {
-    EXPECT_EQ(padding_frame_count + 2u, writer_->frame_count());
-    EXPECT_FALSE(writer_->stop_waiting_frames().empty());
-  }
+  EXPECT_EQ(padding_frame_count + 1u, writer_->frame_count());
+  EXPECT_TRUE(writer_->stop_waiting_frames().empty());
   EXPECT_FALSE(writer_->ack_frames().empty());
   EXPECT_FALSE(connection_.HasPendingAcks());
 }
@@ -6615,7 +6402,7 @@
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
   ProcessPacket(2);
-  size_t frames_per_ack = GetParam().no_stop_waiting ? 1 : 2;
+  size_t frames_per_ack = 1;
 
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
   ProcessPacket(3);
@@ -6658,13 +6445,8 @@
       0, NO_FIN);
   // Check that ack is bundled with outgoing data and that delayed ack
   // alarm is reset.
-  if (GetParam().no_stop_waiting) {
-    EXPECT_EQ(2u, writer_->frame_count());
-    EXPECT_TRUE(writer_->stop_waiting_frames().empty());
-  } else {
-    EXPECT_EQ(3u, writer_->frame_count());
-    EXPECT_FALSE(writer_->stop_waiting_frames().empty());
-  }
+  EXPECT_EQ(2u, writer_->frame_count());
+  EXPECT_TRUE(writer_->stop_waiting_frames().empty());
   EXPECT_FALSE(writer_->ack_frames().empty());
   EXPECT_FALSE(connection_.HasPendingAcks());
 }
@@ -6679,13 +6461,8 @@
   ProcessCryptoPacketAtLevel(1, ENCRYPTION_INITIAL);
   connection_.SendCryptoDataWithString("foo", 0);
   // Check that ack is bundled with outgoing crypto data.
-  if (GetParam().no_stop_waiting) {
-    EXPECT_EQ(3u, writer_->frame_count());
-    EXPECT_TRUE(writer_->stop_waiting_frames().empty());
-  } else {
-    EXPECT_EQ(4u, writer_->frame_count());
-    EXPECT_FALSE(writer_->stop_waiting_frames().empty());
-  }
+  EXPECT_EQ(3u, writer_->frame_count());
+  EXPECT_TRUE(writer_->stop_waiting_frames().empty());
   EXPECT_FALSE(connection_.HasPendingAcks());
 }
 
@@ -6728,13 +6505,8 @@
   }
   ProcessCryptoPacketAtLevel(2, ENCRYPTION_INITIAL);
   // Check that ack is sent and that delayed ack alarm is reset.
-  if (GetParam().no_stop_waiting) {
-    EXPECT_EQ(3u, writer_->frame_count());
-    EXPECT_TRUE(writer_->stop_waiting_frames().empty());
-  } else {
-    EXPECT_EQ(4u, writer_->frame_count());
-    EXPECT_FALSE(writer_->stop_waiting_frames().empty());
-  }
+  EXPECT_EQ(3u, writer_->frame_count());
+  EXPECT_TRUE(writer_->stop_waiting_frames().empty());
   if (!QuicVersionUsesCryptoFrames(connection_.transport_version())) {
     EXPECT_EQ(1u, writer_->stream_frames().size());
   } else {
@@ -6772,13 +6544,8 @@
     ProcessCryptoPacketAtLevel(2, ENCRYPTION_INITIAL);
   }
   // Check that ack is sent and that delayed ack alarm is reset.
-  if (GetParam().no_stop_waiting) {
-    EXPECT_EQ(3u, writer_->frame_count());
-    EXPECT_TRUE(writer_->stop_waiting_frames().empty());
-  } else {
-    EXPECT_EQ(4u, writer_->frame_count());
-    EXPECT_FALSE(writer_->stop_waiting_frames().empty());
-  }
+  EXPECT_EQ(3u, writer_->frame_count());
+  EXPECT_TRUE(writer_->stop_waiting_frames().empty());
   if (!QuicVersionUsesCryptoFrames(connection_.transport_version())) {
     EXPECT_EQ(1u, writer_->stream_frames().size());
   } else {
@@ -6835,20 +6602,9 @@
 
   // Check that ack is bundled with outgoing data and the delayed ack
   // alarm is reset.
-  if (GetParam().no_stop_waiting) {
-    // Do not ACK acks.
-    EXPECT_EQ(1u, writer_->frame_count());
-  } else {
-    EXPECT_EQ(3u, writer_->frame_count());
-    EXPECT_FALSE(writer_->stop_waiting_frames().empty());
-  }
-  if (GetParam().no_stop_waiting) {
-    EXPECT_TRUE(writer_->ack_frames().empty());
-  } else {
-    EXPECT_FALSE(writer_->ack_frames().empty());
-    EXPECT_EQ(QuicPacketNumber(3u),
-              LargestAcked(writer_->ack_frames().front()));
-  }
+  // Do not ACK acks.
+  EXPECT_EQ(1u, writer_->frame_count());
+  EXPECT_TRUE(writer_->ack_frames().empty());
   EXPECT_EQ(1u, writer_->stream_frames().size());
   EXPECT_FALSE(connection_.HasPendingAcks());
 }
@@ -6976,29 +6732,7 @@
                                             connection_.peer_address());
 }
 
-TEST_P(QuicConnectionTest, PublicReset) {
-  if (GetParam().version.HasIetfInvariantHeader()) {
-    return;
-  }
-  QuicPublicResetPacket header;
-  // Public reset packet in only built by server.
-  header.connection_id = connection_id_;
-  std::unique_ptr<QuicEncryptedPacket> packet(
-      framer_.BuildPublicResetPacket(header));
-  std::unique_ptr<QuicReceivedPacket> received(
-      ConstructReceivedPacket(*packet, QuicTime::Zero()));
-  EXPECT_CALL(visitor_, OnConnectionClosed(_, ConnectionCloseSource::FROM_PEER))
-      .WillOnce(Invoke(this, &QuicConnectionTest::SaveConnectionCloseFrame));
-  connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, *received);
-  EXPECT_EQ(1, connection_close_frame_count_);
-  EXPECT_THAT(saved_connection_close_frame_.quic_error_code,
-              IsError(QUIC_PUBLIC_RESET));
-}
-
 TEST_P(QuicConnectionTest, IetfStatelessReset) {
-  if (!GetParam().version.HasIetfInvariantHeader()) {
-    return;
-  }
   QuicConfig config;
   QuicConfigPeer::SetReceivedStatelessResetToken(&config,
                                                  kTestStatelessResetToken);
@@ -7062,17 +6796,6 @@
   connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, encrypted);
 }
 
-TEST_P(QuicConnectionTest, MissingPacketsBeforeLeastUnacked) {
-  if (GetParam().version.HasIetfInvariantHeader()) {
-    return;
-  }
-  // Set the packet number of the ack packet to be least unacked (4).
-  QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 3);
-  EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
-  ProcessStopWaitingPacket(InitStopWaitingFrame(4));
-  EXPECT_FALSE(connection_.ack_frame().packets.Empty());
-}
-
 TEST_P(QuicConnectionTest, ClientHandlesVersionNegotiation) {
   // All supported versions except the one the connection supports.
   ParsedQuicVersionVector versions;
@@ -7085,8 +6808,7 @@
   // Send a version negotiation packet.
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       QuicFramer::BuildVersionNegotiationPacket(
-          connection_id_, EmptyQuicConnectionId(),
-          connection_.version().HasIetfInvariantHeader(),
+          connection_id_, EmptyQuicConnectionId(), /*ietf_quic=*/true,
           connection_.version().HasLengthPrefixedConnectionIds(), versions));
   std::unique_ptr<QuicReceivedPacket> received(
       ConstructReceivedPacket(*encrypted, QuicTime::Zero()));
@@ -7120,8 +6842,7 @@
   // Send a version negotiation packet.
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       QuicFramer::BuildVersionNegotiationPacket(
-          connection_id_, EmptyQuicConnectionId(),
-          connection_.version().HasIetfInvariantHeader(),
+          connection_id_, EmptyQuicConnectionId(), /*ietf_quic=*/true,
           connection_.version().HasLengthPrefixedConnectionIds(), versions));
   std::unique_ptr<QuicReceivedPacket> received(
       ConstructReceivedPacket(*encrypted, QuicTime::Zero()));
@@ -7143,8 +6864,7 @@
       .WillOnce(Invoke(this, &QuicConnectionTest::SaveConnectionCloseFrame));
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       QuicFramer::BuildVersionNegotiationPacket(
-          connection_id_, EmptyQuicConnectionId(),
-          connection_.version().HasIetfInvariantHeader(),
+          connection_id_, EmptyQuicConnectionId(), /*ietf_quic=*/true,
           connection_.version().HasLengthPrefixedConnectionIds(),
           AllSupportedVersions()));
   std::unique_ptr<QuicReceivedPacket> received(
@@ -7161,14 +6881,9 @@
   if (peer_framer_.perspective() == Perspective::IS_SERVER) {
     header.source_connection_id = connection_id_;
     header.destination_connection_id_included = CONNECTION_ID_ABSENT;
-    if (!peer_framer_.version().HasIetfInvariantHeader()) {
-      header.source_connection_id_included = CONNECTION_ID_PRESENT;
-    }
   } else {
     header.destination_connection_id = connection_id_;
-    if (peer_framer_.version().HasIetfInvariantHeader()) {
-      header.destination_connection_id_included = CONNECTION_ID_ABSENT;
-    }
+    header.destination_connection_id_included = CONNECTION_ID_ABSENT;
   }
   header.packet_number = QuicPacketNumber(1);
   header.version_flag = false;
@@ -7274,9 +6989,7 @@
 TEST_P(QuicConnectionTest, OnPacketHeaderDebugVisitor) {
   QuicPacketHeader header;
   header.packet_number = QuicPacketNumber(1);
-  if (GetParam().version.HasIetfInvariantHeader()) {
-    header.form = IETF_QUIC_LONG_HEADER_PACKET;
-  }
+  header.form = IETF_QUIC_LONG_HEADER_PACKET;
 
   MockQuicConnectionDebugVisitor debug_visitor;
   connection_.set_debug_visitor(&debug_visitor);
@@ -8384,11 +8097,7 @@
   // Simulate the alarm firing and check that a PING is sent.
   connection_.GetPingAlarm()->Fire();
   size_t padding_frame_count = writer_->padding_frames().size();
-  if (GetParam().no_stop_waiting) {
-    EXPECT_EQ(padding_frame_count + 2u, writer_->frame_count());
-  } else {
-    EXPECT_EQ(padding_frame_count + 3u, writer_->frame_count());
-  }
+  EXPECT_EQ(padding_frame_count + 2u, writer_->frame_count());
   ASSERT_EQ(1u, writer_->ping_frames().size());
 }
 
@@ -8454,12 +8163,8 @@
   writer_->Reset();
   connection_.GetPingAlarm()->Fire();
   size_t padding_frame_count = writer_->padding_frames().size();
-  if (GetParam().no_stop_waiting) {
-    // Do not ACK acks.
-    EXPECT_EQ(padding_frame_count + 1u, writer_->frame_count());
-  } else {
-    EXPECT_EQ(padding_frame_count + 3u, writer_->frame_count());
-  }
+  // Do not ACK acks.
+  EXPECT_EQ(padding_frame_count + 1u, writer_->frame_count());
   ASSERT_EQ(1u, writer_->ping_frames().size());
 }
 
@@ -8773,9 +8478,6 @@
 }
 
 TEST_P(QuicConnectionTest, SendMessage) {
-  if (!VersionSupportsMessageFrames(connection_.transport_version())) {
-    return;
-  }
   if (connection_.version().UsesTls()) {
     QuicConfig config;
     QuicConfigPeer::SetReceivedMaxDatagramFrameSize(
@@ -8812,9 +8514,6 @@
 }
 
 TEST_P(QuicConnectionTest, GetCurrentLargestMessagePayload) {
-  if (!connection_.version().SupportsMessageFrames()) {
-    return;
-  }
   QuicPacketLength expected_largest_payload = 1215;
   if (connection_.version().SendsVariableLengthPacketNumberInLongHeader()) {
     expected_largest_payload += 3;
@@ -8843,9 +8542,6 @@
 }
 
 TEST_P(QuicConnectionTest, GetGuaranteedLargestMessagePayload) {
-  if (!connection_.version().SupportsMessageFrames()) {
-    return;
-  }
   QuicPacketLength expected_largest_payload = 1215;
   if (connection_.version().HasLongHeaderLengths()) {
     expected_largest_payload -= 2;
@@ -8871,8 +8567,7 @@
 }
 
 TEST_P(QuicConnectionTest, LimitedLargestMessagePayload) {
-  if (!connection_.version().SupportsMessageFrames() ||
-      !connection_.version().UsesTls()) {
+  if (!connection_.version().UsesTls()) {
     return;
   }
   constexpr QuicPacketLength kFrameSizeLimit = 1000;
@@ -9171,41 +8866,6 @@
             QuicConnectionPeer::GetCurrentPacketContent(&connection_));
 }
 
-// Regression test for b/120791670
-TEST_P(QuicConnectionTest, StopProcessingGQuicPacketInIetfQuicConnection) {
-  // This test mimics a problematic scenario where a QUIC connection using a
-  // modern version received a Q043 packet and processed it incorrectly.
-  // We can remove this test once Q043 is deprecated.
-  if (!version().HasIetfInvariantHeader()) {
-    return;
-  }
-  set_perspective(Perspective::IS_SERVER);
-  if (QuicVersionUsesCryptoFrames(connection_.transport_version())) {
-    EXPECT_CALL(visitor_, OnCryptoFrame(_)).Times(1);
-  } else {
-    EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
-  }
-  ProcessFramePacketWithAddresses(MakeCryptoFrame(), kSelfAddress, kPeerAddress,
-                                  ENCRYPTION_INITIAL);
-
-  // Let connection process a Google QUIC packet.
-  peer_framer_.set_version_for_tests(ParsedQuicVersion::Q043());
-  std::unique_ptr<QuicPacket> packet(
-      ConstructDataPacket(2, !kHasStopWaiting, ENCRYPTION_INITIAL));
-  char buffer[kMaxOutgoingPacketSize];
-  size_t encrypted_length =
-      peer_framer_.EncryptPayload(ENCRYPTION_INITIAL, QuicPacketNumber(2),
-                                  *packet, buffer, kMaxOutgoingPacketSize);
-  // Make sure no stream frame is processed.
-  EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(0);
-  connection_.ProcessUdpPacket(
-      kSelfAddress, kPeerAddress,
-      QuicReceivedPacket(buffer, encrypted_length, clock_.Now(), false));
-
-  EXPECT_EQ(2u, connection_.GetStats().packets_received);
-  EXPECT_EQ(1u, connection_.GetStats().packets_processed);
-}
-
 TEST_P(QuicConnectionTest, AcceptPacketNumberZero) {
   if (!VersionHasIetfQuicFrames(version().transport_version)) {
     return;
@@ -10812,9 +10472,6 @@
 
 // Regression test for b/151220135.
 TEST_P(QuicConnectionTest, SendPingWhenSkipPacketNumberForPto) {
-  if (!VersionSupportsMessageFrames(connection_.transport_version())) {
-    return;
-  }
   QuicConfig config;
   QuicTagVector connection_options;
   connection_options.push_back(kPTOS);
diff --git a/quiche/quic/core/quic_crypto_stream.cc b/quiche/quic/core/quic_crypto_stream.cc
index 31c2180..925baa6 100644
--- a/quiche/quic/core/quic_crypto_stream.cc
+++ b/quiche/quic/core/quic_crypto_stream.cc
@@ -59,9 +59,7 @@
   }
   return QuicPacketCreator::StreamFramePacketOverhead(
       version, connection_id.length(), 0, /*include_version=*/true,
-      /*include_diversification_nonce=*/true,
-      VersionHasIetfInvariantHeader(version) ? PACKET_4BYTE_PACKET_NUMBER
-                                             : PACKET_1BYTE_PACKET_NUMBER,
+      /*include_diversification_nonce=*/true, PACKET_4BYTE_PACKET_NUMBER,
       retry_token_length_length, length_length,
       /*offset=*/0);
 }
diff --git a/quiche/quic/core/quic_crypto_stream_test.cc b/quiche/quic/core/quic_crypto_stream_test.cc
index cd6d3cf..76f840b 100644
--- a/quiche/quic/core/quic_crypto_stream_test.cc
+++ b/quiche/quic/core/quic_crypto_stream_test.cc
@@ -639,10 +639,7 @@
   for (const ParsedQuicVersion& version :
        AllSupportedVersionsWithQuicCrypto()) {
     SCOPED_TRACE(version);
-    QuicByteCount expected_overhead = 48;
-    if (version.HasIetfInvariantHeader()) {
-      expected_overhead += 4;
-    }
+    QuicByteCount expected_overhead = 52;
     if (version.HasLongHeaderLengths()) {
       expected_overhead += 3;
     }
diff --git a/quiche/quic/core/quic_dispatcher.cc b/quiche/quic/core/quic_dispatcher.cc
index 9b1b470..d92ffff 100644
--- a/quiche/quic/core/quic_dispatcher.cc
+++ b/quiche/quic/core/quic_dispatcher.cc
@@ -703,19 +703,6 @@
     return result;
   }
 
-  // We only apply this check for versions that do not use the IETF
-  // invariant header because those versions are already checked in
-  // QuicDispatcher::MaybeDispatchPacket.
-  if (packet_info.version_flag &&
-      !packet_info.version.HasIetfInvariantHeader() &&
-      crypto_config()->validate_chlo_size() &&
-      packet_info.packet.length() < kMinClientInitialPacketLength) {
-    QUIC_DVLOG(1) << "Dropping CHLO packet which is too short, length: "
-                  << packet_info.packet.length();
-    QUIC_CODE_COUNT(quic_drop_small_chlo_packets);
-    return result;
-  }
-
   ParsedClientHello& parsed_chlo = result.parsed_chlo.emplace();
   parsed_chlo.sni = alpn_extractor.ConsumeSni();
   parsed_chlo.uaid = alpn_extractor.ConsumeUaid();
@@ -769,11 +756,7 @@
     if (!connection->IsHandshakeComplete()) {
       // TODO(fayang): Do not serialize connection close packet if the
       // connection is closed by the client.
-      if (!connection->version().HasIetfInvariantHeader()) {
-        QUIC_CODE_COUNT(gquic_add_to_time_wait_list_with_handshake_failed);
-      } else {
-        QUIC_CODE_COUNT(quic_v44_add_to_time_wait_list_with_handshake_failed);
-      }
+      QUIC_CODE_COUNT(quic_v44_add_to_time_wait_list_with_handshake_failed);
       // This serializes a connection close termination packet and adds the
       // connection to the time wait list.
       StatelessConnectionTerminator terminator(
@@ -783,8 +766,7 @@
       terminator.CloseConnection(
           QUIC_HANDSHAKE_FAILED,
           "Connection is closed by server before handshake confirmed",
-          connection->version().HasIetfInvariantHeader(),
-          connection->GetActiveServerConnectionIds());
+          /*ietf_quic=*/true, connection->GetActiveServerConnectionIds());
       return;
     }
     QUIC_CODE_COUNT(quic_v44_add_to_time_wait_list_with_stateless_reset);
@@ -792,8 +774,7 @@
   time_wait_list_manager_->AddConnectionIdToTimeWait(
       action,
       TimeWaitConnectionInfo(
-          connection->version().HasIetfInvariantHeader(),
-          connection->termination_packets(),
+          /*ietf_quic=*/true, connection->termination_packets(),
           connection->GetActiveServerConnectionIds(),
           connection->sent_packet_manager().GetRttStats()->smoothed_rtt()));
 }
diff --git a/quiche/quic/core/quic_dispatcher_test.cc b/quiche/quic/core/quic_dispatcher_test.cc
index 12a62bb..ff2516a 100644
--- a/quiche/quic/core/quic_dispatcher_test.cc
+++ b/quiche/quic/core/quic_dispatcher_test.cc
@@ -953,14 +953,7 @@
 
   uint8_t short_packet[22] = {0x70, 0xa7, 0x02, 0x6b};
   uint8_t valid_size_packet[23] = {0x70, 0xa7, 0x02, 0x6c};
-  size_t short_packet_len;
-  if (version_.HasIetfInvariantHeader()) {
-    short_packet_len = 21;
-  } else {
-    short_packet_len = 22;
-    short_packet[0] = 0x0a;
-    valid_size_packet[0] = 0x0a;
-  }
+  size_t short_packet_len = 21;
   QuicReceivedPacket packet(reinterpret_cast<char*>(short_packet),
                             short_packet_len, QuicTime::Zero());
   QuicReceivedPacket packet2(reinterpret_cast<char*>(valid_size_packet),
@@ -971,21 +964,13 @@
   EXPECT_CALL(*time_wait_list_manager_, AddConnectionIdToTimeWait(_, _))
       .Times(0);
   // Verify small packet is silently dropped.
-  if (version_.HasIetfInvariantHeader()) {
-    EXPECT_CALL(connection_id_generator_, ConnectionIdLength(0xa7))
-        .WillOnce(Return(kQuicDefaultConnectionIdLength));
-  } else {
-    EXPECT_CALL(connection_id_generator_, ConnectionIdLength(_)).Times(0);
-  }
+  EXPECT_CALL(connection_id_generator_, ConnectionIdLength(0xa7))
+      .WillOnce(Return(kQuicDefaultConnectionIdLength));
   EXPECT_CALL(*time_wait_list_manager_, SendPublicReset(_, _, _, _, _, _))
       .Times(0);
   dispatcher_->ProcessPacket(server_address_, client_address, packet);
-  if (version_.HasIetfInvariantHeader()) {
-    EXPECT_CALL(connection_id_generator_, ConnectionIdLength(0xa7))
-        .WillOnce(Return(kQuicDefaultConnectionIdLength));
-  } else {
-    EXPECT_CALL(connection_id_generator_, ConnectionIdLength(_)).Times(0);
-  }
+  EXPECT_CALL(connection_id_generator_, ConnectionIdLength(0xa7))
+      .WillOnce(Return(kQuicDefaultConnectionIdLength));
   EXPECT_CALL(*time_wait_list_manager_, SendPublicReset(_, _, _, _, _, _))
       .Times(1);
   dispatcher_->ProcessPacket(server_address_, client_address, packet2);
@@ -1521,7 +1506,7 @@
   dispatcher_->ProcessPacket(server_address_, client_address, received_packet);
 }
 
-static_assert(quic::SupportedVersions().size() == 6u,
+static_assert(quic::SupportedVersions().size() == 5u,
               "Please add new RejectDeprecatedVersion tests above this assert "
               "when deprecating versions");
 
diff --git a/quiche/quic/core/quic_flags_list.h b/quiche/quic/core/quic_flags_list.h
index 7f6ba62..39bb408 100644
--- a/quiche/quic/core/quic_flags_list.h
+++ b/quiche/quic/core/quic_flags_list.h
@@ -29,8 +29,6 @@
 QUIC_FLAG(quic_reloadable_flag_quic_no_path_degrading_before_handshake_confirmed, true)
 // If true, default-enable 5RTO blachole detection.
 QUIC_FLAG(quic_reloadable_flag_quic_default_enable_5rto_blackhole_detection2, true)
-// If true, disable QUIC version Q043.
-QUIC_FLAG(quic_reloadable_flag_quic_disable_version_q043, true)
 // If true, disable QUIC version Q046.
 QUIC_FLAG(quic_reloadable_flag_quic_disable_version_q046, true)
 // If true, disable QUIC version Q050.
diff --git a/quiche/quic/core/quic_framer.cc b/quiche/quic/core/quic_framer.cc
index f06f205..b2b1278 100644
--- a/quiche/quic/core/quic_framer.cc
+++ b/quiche/quic/core/quic_framer.cc
@@ -63,10 +63,6 @@
 #define ENDPOINT \
   (perspective_ == Perspective::IS_SERVER ? "Server: " : "Client: ")
 
-// Number of bits the packet number length bits are shifted from the right
-// edge of the header.
-const uint8_t kPublicHeaderSequenceNumberShift = 4;
-
 // There are two interpretations for the Frame Type byte in the QUIC protocol,
 // resulting in two Frame Types: Special Frame Types and Regular Frame Types.
 //
@@ -89,7 +85,6 @@
 
 // Masks to determine if the frame type is a special use
 // and for specific special frame types.
-const uint8_t kQuicFrameTypeBrokenMask = 0xE0;   // 0b 11100000
 const uint8_t kQuicFrameTypeSpecialMask = 0xC0;  // 0b 11000000
 const uint8_t kQuicFrameTypeStreamMask = 0x80;
 const uint8_t kQuicFrameTypeAckMask = 0x40;
@@ -160,22 +155,6 @@
   return (Delta(target, a) < Delta(target, b)) ? a : b;
 }
 
-QuicPacketNumberLength ReadSequenceNumberLength(uint8_t flags) {
-  switch (flags & PACKET_FLAGS_8BYTE_PACKET) {
-    case PACKET_FLAGS_8BYTE_PACKET:
-      return PACKET_6BYTE_PACKET_NUMBER;
-    case PACKET_FLAGS_4BYTE_PACKET:
-      return PACKET_4BYTE_PACKET_NUMBER;
-    case PACKET_FLAGS_2BYTE_PACKET:
-      return PACKET_2BYTE_PACKET_NUMBER;
-    case PACKET_FLAGS_1BYTE_PACKET:
-      return PACKET_1BYTE_PACKET_NUMBER;
-    default:
-      QUIC_BUG(quic_bug_10850_1) << "Unreachable case statement.";
-      return PACKET_6BYTE_PACKET_NUMBER;
-  }
-}
-
 QuicPacketNumberLength ReadAckPacketNumberLength(uint8_t flags) {
   switch (flags & PACKET_FLAGS_8BYTE_PACKET) {
     case PACKET_FLAGS_8BYTE_PACKET:
@@ -471,11 +450,8 @@
 }
 
 // static
-size_t QuicFramer::GetMessageFrameSize(QuicTransportVersion version,
-                                       bool last_frame_in_packet,
+size_t QuicFramer::GetMessageFrameSize(bool last_frame_in_packet,
                                        QuicByteCount length) {
-  QUIC_BUG_IF(quic_bug_12975_1, !VersionSupportsMessageFrames(version))
-      << "Try to serialize MESSAGE frame in " << version;
   return kQuicFrameTypeSize +
          (last_frame_in_packet ? 0 : QuicDataWriter::GetVarInt62Len(length)) +
          length;
@@ -890,13 +866,13 @@
                                    const QuicFrames& frames, char* buffer,
                                    size_t packet_length,
                                    EncryptionLevel level) {
-  QUIC_BUG_IF(quic_bug_12975_2,
-              header.version_flag && version().HasIetfInvariantHeader() &&
-                  header.long_packet_type == RETRY && !frames.empty())
+  QUIC_BUG_IF(quic_bug_12975_2, header.version_flag &&
+                                    header.long_packet_type == RETRY &&
+                                    !frames.empty())
       << "IETF RETRY packets cannot contain frames " << header;
   QuicDataWriter writer(packet_length, buffer);
   size_t length_field_offset = 0;
-  if (!AppendPacketHeader(header, &writer, &length_field_offset)) {
+  if (!AppendIetfPacketHeader(header, &writer, &length_field_offset)) {
     QUIC_BUG(quic_bug_10850_16) << "AppendPacketHeader failed";
     return 0;
   }
@@ -944,13 +920,6 @@
           return 0;
         }
         break;
-      case STOP_WAITING_FRAME:
-        if (!AppendStopWaitingFrame(header, frame.stop_waiting_frame,
-                                    &writer)) {
-          QUIC_BUG(quic_bug_10850_21) << "AppendStopWaitingFrame failed";
-          return 0;
-        }
-        break;
       case MTU_DISCOVERY_FRAME:
         // MTU discovery frames are serialized as ping frames.
         ABSL_FALLTHROUGH_INTENDED;
@@ -1481,16 +1450,12 @@
 
 bool QuicFramer::ProcessPacketInternal(const QuicEncryptedPacket& packet) {
   QuicDataReader reader(packet.data(), packet.length());
-
-  const bool packet_has_ietf_packet_header = version_.HasIetfInvariantHeader();
-  if (packet_has_ietf_packet_header) {
-    QUIC_DVLOG(1) << ENDPOINT << "Processing IETF QUIC packet.";
-  }
+  QUIC_DVLOG(1) << ENDPOINT << "Processing IETF QUIC packet.";
 
   visitor_->OnPacket();
 
   QuicPacketHeader header;
-  if (!ProcessPublicHeader(&reader, packet_has_ietf_packet_header, &header)) {
+  if (!ProcessIetfPacketHeader(&reader, &header)) {
     QUICHE_DCHECK_NE("", detailed_error_);
     QUIC_DVLOG(1) << ENDPOINT << "Unable to process public header. Error: "
                   << detailed_error_;
@@ -1504,7 +1469,7 @@
     return true;
   }
 
-  if (IsVersionNegotiation(header, packet_has_ietf_packet_header)) {
+  if (IsVersionNegotiation(header)) {
     if (perspective_ == Perspective::IS_CLIENT) {
       QUIC_DVLOG(1) << "Client received version negotiation packet";
       return ProcessVersionNegotiationPacket(&reader, header);
@@ -1535,28 +1500,16 @@
   bool rv;
   if (header.long_packet_type == RETRY) {
     rv = ProcessRetryPacket(&reader, header);
-  } else if (header.reset_flag) {
-    rv = ProcessPublicResetPacket(&reader, header);
   } else if (packet.length() <= kMaxIncomingPacketSize) {
     // The optimized decryption algorithm implementations run faster when
     // operating on aligned memory.
     ABSL_CACHELINE_ALIGNED char buffer[kMaxIncomingPacketSize];
-    if (packet_has_ietf_packet_header) {
-      rv = ProcessIetfDataPacket(&reader, &header, packet, buffer,
-                                 ABSL_ARRAYSIZE(buffer));
-    } else {
-      rv = ProcessDataPacket(&reader, &header, packet, buffer,
-                             ABSL_ARRAYSIZE(buffer));
-    }
+    rv = ProcessIetfDataPacket(&reader, &header, packet, buffer,
+                               ABSL_ARRAYSIZE(buffer));
   } else {
     std::unique_ptr<char[]> large_buffer(new char[packet.length()]);
-    if (packet_has_ietf_packet_header) {
-      rv = ProcessIetfDataPacket(&reader, &header, packet, large_buffer.get(),
-                                 packet.length());
-    } else {
-      rv = ProcessDataPacket(&reader, &header, packet, large_buffer.get(),
-                             packet.length());
-    }
+    rv = ProcessIetfDataPacket(&reader, &header, packet, large_buffer.get(),
+                               packet.length());
     QUIC_BUG_IF(quic_bug_10850_53, rv)
         << "QUIC should never successfully process packets larger"
         << "than kMaxIncomingPacketSize. packet size:" << packet.length();
@@ -1969,130 +1922,6 @@
   return true;
 }
 
-bool QuicFramer::ProcessDataPacket(QuicDataReader* encrypted_reader,
-                                   QuicPacketHeader* header,
-                                   const QuicEncryptedPacket& packet,
-                                   char* decrypted_buffer,
-                                   size_t buffer_length) {
-  if (!ProcessUnauthenticatedHeader(encrypted_reader, header)) {
-    QUICHE_DCHECK_NE("", detailed_error_);
-    QUIC_DVLOG(1)
-        << ENDPOINT
-        << "Unable to process packet header. Stopping parsing. Error: "
-        << detailed_error_;
-    RecordDroppedPacketReason(DroppedPacketReason::INVALID_PACKET_NUMBER);
-    return false;
-  }
-
-  absl::string_view encrypted = encrypted_reader->ReadRemainingPayload();
-  absl::string_view associated_data = GetAssociatedDataFromEncryptedPacket(
-      version_.transport_version, packet,
-      GetIncludedDestinationConnectionIdLength(*header),
-      GetIncludedSourceConnectionIdLength(*header), header->version_flag,
-      header->nonce != nullptr, header->packet_number_length,
-      header->retry_token_length_length, header->retry_token.length(),
-      header->length_length);
-
-  size_t decrypted_length = 0;
-  EncryptionLevel decrypted_level;
-  if (!DecryptPayload(packet.length(), encrypted, associated_data, *header,
-                      decrypted_buffer, buffer_length, &decrypted_length,
-                      &decrypted_level)) {
-    const EncryptionLevel decryption_level = decrypter_level_;
-    // This version uses trial decryption so we always report to our visitor
-    // that we are not certain we have the correct decryption key.
-    const bool has_decryption_key = false;
-    visitor_->OnUndecryptablePacket(
-        QuicEncryptedPacket(encrypted_reader->FullPayload()), decryption_level,
-        has_decryption_key);
-    RecordDroppedPacketReason(DroppedPacketReason::DECRYPTION_FAILURE);
-    set_detailed_error(absl::StrCat("Unable to decrypt ",
-                                    EncryptionLevelToString(decryption_level),
-                                    " payload."));
-    return RaiseError(QUIC_DECRYPTION_FAILURE);
-  }
-
-  QuicDataReader reader(decrypted_buffer, decrypted_length);
-
-  // Update the largest packet number after we have decrypted the packet
-  // so we are confident is not attacker controlled.
-  if (supports_multiple_packet_number_spaces_) {
-    largest_decrypted_packet_numbers_[QuicUtils::GetPacketNumberSpace(
-                                          decrypted_level)]
-        .UpdateMax(header->packet_number);
-  } else {
-    largest_packet_number_.UpdateMax(header->packet_number);
-  }
-
-  if (!visitor_->OnPacketHeader(*header)) {
-    // The visitor suppresses further processing of the packet.
-    return true;
-  }
-
-  if (packet.length() > kMaxIncomingPacketSize) {
-    set_detailed_error("Packet too large.");
-    return RaiseError(QUIC_PACKET_TOO_LARGE);
-  }
-
-  // Handle the payload.
-  if (!ProcessFrameData(&reader, *header)) {
-    QUICHE_DCHECK_NE(QUIC_NO_ERROR,
-                     error_);  // ProcessFrameData sets the error.
-    QUICHE_DCHECK_NE("", detailed_error_);
-    QUIC_DLOG(WARNING) << ENDPOINT << "Unable to process frame data. Error: "
-                       << detailed_error_;
-    return false;
-  }
-
-  visitor_->OnPacketComplete();
-  return true;
-}
-
-bool QuicFramer::ProcessPublicResetPacket(QuicDataReader* reader,
-                                          const QuicPacketHeader& header) {
-  QuicPublicResetPacket packet(
-      GetServerConnectionIdAsRecipient(header, perspective_));
-
-  std::unique_ptr<CryptoHandshakeMessage> reset(
-      CryptoFramer::ParseMessage(reader->ReadRemainingPayload()));
-  if (!reset) {
-    set_detailed_error("Unable to read reset message.");
-    RecordDroppedPacketReason(DroppedPacketReason::INVALID_PUBLIC_RESET_PACKET);
-    return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET);
-  }
-  if (reset->tag() != kPRST) {
-    set_detailed_error("Incorrect message tag.");
-    RecordDroppedPacketReason(DroppedPacketReason::INVALID_PUBLIC_RESET_PACKET);
-    return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET);
-  }
-
-  if (reset->GetUint64(kRNON, &packet.nonce_proof) != QUIC_NO_ERROR) {
-    set_detailed_error("Unable to read nonce proof.");
-    RecordDroppedPacketReason(DroppedPacketReason::INVALID_PUBLIC_RESET_PACKET);
-    return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET);
-  }
-  // TODO(satyamshekhar): validate nonce to protect against DoS.
-
-  absl::string_view address;
-  if (reset->GetStringPiece(kCADR, &address)) {
-    QuicSocketAddressCoder address_coder;
-    if (address_coder.Decode(address.data(), address.length())) {
-      packet.client_address =
-          QuicSocketAddress(address_coder.ip(), address_coder.port());
-    }
-  }
-
-  absl::string_view endpoint_id;
-  if (perspective_ == Perspective::IS_CLIENT &&
-      reset->GetStringPiece(kEPID, &endpoint_id)) {
-    packet.endpoint_id = std::string(endpoint_id);
-    packet.endpoint_id += '\0';
-  }
-
-  visitor_->OnPublicResetPacket(packet);
-  return true;
-}
-
 bool QuicFramer::IsIetfStatelessResetPacket(
     const QuicPacketHeader& header) const {
   QUIC_BUG_IF(quic_bug_12975_3, header.has_possible_stateless_reset_token &&
@@ -2144,89 +1973,6 @@
   return ENCRYPTION_ZERO_RTT;
 }
 
-bool QuicFramer::AppendPacketHeader(const QuicPacketHeader& header,
-                                    QuicDataWriter* writer,
-                                    size_t* length_field_offset) {
-  if (version().HasIetfInvariantHeader()) {
-    return AppendIetfPacketHeader(header, writer, length_field_offset);
-  }
-  QUIC_DVLOG(1) << ENDPOINT << "Appending header: " << header;
-  uint8_t public_flags = 0;
-  if (header.reset_flag) {
-    public_flags |= PACKET_PUBLIC_FLAGS_RST;
-  }
-  if (header.version_flag) {
-    public_flags |= PACKET_PUBLIC_FLAGS_VERSION;
-  }
-
-  public_flags |= GetPacketNumberFlags(header.packet_number_length)
-                  << kPublicHeaderSequenceNumberShift;
-
-  if (header.nonce != nullptr) {
-    QUICHE_DCHECK_EQ(Perspective::IS_SERVER, perspective_);
-    public_flags |= PACKET_PUBLIC_FLAGS_NONCE;
-  }
-
-  QuicConnectionId server_connection_id =
-      GetServerConnectionIdAsSender(header, perspective_);
-  QuicConnectionIdIncluded server_connection_id_included =
-      GetServerConnectionIdIncludedAsSender(header, perspective_);
-  QUICHE_DCHECK_EQ(CONNECTION_ID_ABSENT,
-                   GetClientConnectionIdIncludedAsSender(header, perspective_))
-      << ENDPOINT << ParsedQuicVersionToString(version_)
-      << " invalid header: " << header;
-
-  switch (server_connection_id_included) {
-    case CONNECTION_ID_ABSENT:
-      if (!writer->WriteUInt8(public_flags |
-                              PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID)) {
-        return false;
-      }
-      break;
-    case CONNECTION_ID_PRESENT:
-      QUIC_BUG_IF(quic_bug_12975_5,
-                  !QuicUtils::IsConnectionIdValidForVersion(
-                      server_connection_id, transport_version()))
-          << "AppendPacketHeader: attempted to use connection ID "
-          << server_connection_id << " which is invalid with version "
-          << version();
-
-      public_flags |= PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID;
-      if (perspective_ == Perspective::IS_CLIENT) {
-        public_flags |= PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID_OLD;
-      }
-      if (!writer->WriteUInt8(public_flags) ||
-          !writer->WriteConnectionId(server_connection_id)) {
-        return false;
-      }
-      break;
-  }
-  last_serialized_server_connection_id_ = server_connection_id;
-
-  if (header.version_flag) {
-    QUICHE_DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
-    QuicVersionLabel version_label = CreateQuicVersionLabel(version_);
-    if (!writer->WriteUInt32(version_label)) {
-      return false;
-    }
-
-    QUIC_DVLOG(1) << ENDPOINT << "label = '"
-                  << QuicVersionLabelToString(version_label) << "'";
-  }
-
-  if (header.nonce != nullptr &&
-      !writer->WriteBytes(header.nonce, kDiversificationNonceSize)) {
-    return false;
-  }
-
-  if (!AppendPacketNumber(header.packet_number_length, header.packet_number,
-                          writer)) {
-    return false;
-  }
-
-  return true;
-}
-
 bool QuicFramer::AppendIetfHeaderTypeByte(const QuicPacketHeader& header,
                                           QuicDataWriter* writer) {
   uint8_t type = 0;
@@ -2388,97 +2134,6 @@
                              next_epoch + packet_number));
 }
 
-bool QuicFramer::ProcessPublicHeader(QuicDataReader* reader,
-                                     bool packet_has_ietf_packet_header,
-                                     QuicPacketHeader* header) {
-  if (packet_has_ietf_packet_header) {
-    return ProcessIetfPacketHeader(reader, header);
-  }
-  uint8_t public_flags;
-  if (!reader->ReadBytes(&public_flags, 1)) {
-    set_detailed_error("Unable to read public flags.");
-    return false;
-  }
-
-  header->reset_flag = (public_flags & PACKET_PUBLIC_FLAGS_RST) != 0;
-  header->version_flag = (public_flags & PACKET_PUBLIC_FLAGS_VERSION) != 0;
-
-  if (validate_flags_ && !header->version_flag &&
-      public_flags > PACKET_PUBLIC_FLAGS_MAX) {
-    set_detailed_error("Illegal public flags value.");
-    return false;
-  }
-
-  if (header->reset_flag && header->version_flag) {
-    set_detailed_error("Got version flag in reset packet");
-    return false;
-  }
-
-  QuicConnectionId* header_connection_id = &header->destination_connection_id;
-  QuicConnectionIdIncluded* header_connection_id_included =
-      &header->destination_connection_id_included;
-  if (perspective_ == Perspective::IS_CLIENT) {
-    header_connection_id = &header->source_connection_id;
-    header_connection_id_included = &header->source_connection_id_included;
-  }
-  switch (public_flags & PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID) {
-    case PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID:
-      if (!reader->ReadConnectionId(header_connection_id,
-                                    kQuicDefaultConnectionIdLength)) {
-        set_detailed_error("Unable to read ConnectionId.");
-        return false;
-      }
-      *header_connection_id_included = CONNECTION_ID_PRESENT;
-      break;
-    case PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID:
-      *header_connection_id_included = CONNECTION_ID_ABSENT;
-      *header_connection_id = last_serialized_server_connection_id_;
-      break;
-  }
-
-  header->packet_number_length = ReadSequenceNumberLength(
-      public_flags >> kPublicHeaderSequenceNumberShift);
-
-  // Read the version only if the packet is from the client.
-  // version flag from the server means version negotiation packet.
-  if (header->version_flag && perspective_ == Perspective::IS_SERVER) {
-    QuicVersionLabel version_label;
-    if (!ProcessVersionLabel(reader, &version_label)) {
-      set_detailed_error("Unable to read protocol version.");
-      return false;
-    }
-    // If the version from the new packet is the same as the version of this
-    // framer, then the public flags should be set to something we understand.
-    // If not, this raises an error.
-    ParsedQuicVersion version = ParseQuicVersionLabel(version_label);
-    if (version == version_ && public_flags > PACKET_PUBLIC_FLAGS_MAX) {
-      set_detailed_error("Illegal public flags value.");
-      return false;
-    }
-    header->version = version;
-  }
-
-  // A nonce should only be present in packets from the server to the client,
-  // which are neither version negotiation nor public reset packets.
-  if (public_flags & PACKET_PUBLIC_FLAGS_NONCE &&
-      !(public_flags & PACKET_PUBLIC_FLAGS_VERSION) &&
-      !(public_flags & PACKET_PUBLIC_FLAGS_RST) &&
-      // The nonce flag from a client is ignored and is assumed to be an older
-      // client indicating an eight-byte connection ID.
-      perspective_ == Perspective::IS_CLIENT) {
-    if (!reader->ReadBytes(reinterpret_cast<uint8_t*>(last_nonce_.data()),
-                           last_nonce_.size())) {
-      set_detailed_error("Unable to read nonce.");
-      return false;
-    }
-    header->nonce = &last_nonce_;
-  } else {
-    header->nonce = nullptr;
-  }
-
-  return true;
-}
-
 // static
 QuicPacketNumberLength QuicFramer::GetMinPacketNumberLength(
     QuicPacketNumber packet_number) {
@@ -2547,57 +2202,6 @@
   return new_ack_info;
 }
 
-bool QuicFramer::ProcessUnauthenticatedHeader(QuicDataReader* encrypted_reader,
-                                              QuicPacketHeader* header) {
-  QuicPacketNumber base_packet_number;
-  if (supports_multiple_packet_number_spaces_) {
-    PacketNumberSpace pn_space = GetPacketNumberSpace(*header);
-    if (pn_space == NUM_PACKET_NUMBER_SPACES) {
-      set_detailed_error("Unable to determine packet number space.");
-      return RaiseError(QUIC_INVALID_PACKET_HEADER);
-    }
-    base_packet_number = largest_decrypted_packet_numbers_[pn_space];
-  } else {
-    base_packet_number = largest_packet_number_;
-  }
-  uint64_t full_packet_number;
-  if (!ProcessAndCalculatePacketNumber(
-          encrypted_reader, header->packet_number_length, base_packet_number,
-          &full_packet_number)) {
-    set_detailed_error("Unable to read packet number.");
-    return RaiseError(QUIC_INVALID_PACKET_HEADER);
-  }
-
-  if (!IsValidFullPacketNumber(full_packet_number, version())) {
-    set_detailed_error("packet numbers cannot be 0.");
-    return RaiseError(QUIC_INVALID_PACKET_HEADER);
-  }
-  header->packet_number = QuicPacketNumber(full_packet_number);
-
-  if (!visitor_->OnUnauthenticatedHeader(*header)) {
-    set_detailed_error(
-        "Visitor asked to stop processing of unauthenticated header.");
-    return false;
-  }
-  // The function we are in is called because the framer believes that it is
-  // processing a packet that uses the non-IETF (i.e. Google QUIC) packet header
-  // type. Usually, the framer makes that decision based on the framer's
-  // version, but when the framer is used with Perspective::IS_SERVER, then
-  // before version negotiation is complete (specifically, before
-  // InferPacketHeaderTypeFromVersion is called), this decision is made based on
-  // the type byte of the packet.
-  //
-  // If the framer's version KnowsWhichDecrypterToUse, then that version expects
-  // to use the IETF packet header type. If that's the case and we're in this
-  // function, then the packet received is invalid: the framer was expecting an
-  // IETF packet header and didn't get one.
-  if (version().KnowsWhichDecrypterToUse()) {
-    set_detailed_error("Invalid public header type for expected version.");
-    return RaiseError(QUIC_INVALID_PACKET_HEADER);
-  }
-  return true;
-}
-
 bool QuicFramer::ProcessIetfHeaderTypeByte(QuicDataReader* reader,
                                            QuicPacketHeader* header) {
   uint8_t type;
@@ -2783,13 +2387,12 @@
     bool has_length_prefix;
     std::string detailed_error;
     QuicErrorCode parse_result = QuicFramer::ParsePublicHeader(
-        reader, expected_destination_connection_id_length,
-        version_.HasIetfInvariantHeader(), &header->type_byte, &header->form,
-        &header->version_flag, &has_length_prefix, &version_label,
-        &header->version, &header->destination_connection_id,
-        &header->source_connection_id, &header->long_packet_type,
-        &header->retry_token_length_length, &header->retry_token,
-        &detailed_error);
+        reader, expected_destination_connection_id_length, /*ietf_format=*/true,
+        &header->type_byte, &header->form, &header->version_flag,
+        &has_length_prefix, &version_label, &header->version,
+        &header->destination_connection_id, &header->source_connection_id,
+        &header->long_packet_type, &header->retry_token_length_length,
+        &header->retry_token, &detailed_error);
     if (parse_result != QUIC_NO_ERROR) {
       set_detailed_error(detailed_error);
       return false;
@@ -2920,10 +2523,7 @@
       set_detailed_error("Unable to read frame type.");
       return RaiseError(QUIC_INVALID_FRAME_DATA);
     }
-    const uint8_t special_mask = version_.HasIetfInvariantHeader()
-                                     ? kQuicFrameTypeSpecialMask
-                                     : kQuicFrameTypeBrokenMask;
-    if (frame_type & special_mask) {
+    if (frame_type & kQuicFrameTypeSpecialMask) {
       // Stream Frame
       if (frame_type & kQuicFrameTypeStreamMask) {
         QuicStreamFrame frame;
@@ -5182,8 +4782,7 @@
       // MTU discovery frames are serialized as ping frames.
       return kQuicFrameTypeSize;
     case MESSAGE_FRAME:
-      return GetMessageFrameSize(version_.transport_version,
-                                 last_frame_in_packet,
+      return GetMessageFrameSize(last_frame_in_packet,
                                  frame.message_frame->message_length);
     case PADDING_FRAME:
       QUICHE_DCHECK(false);
@@ -5991,39 +5590,6 @@
   return FrameAckTimestampRanges(frame, timestamp_ranges, writer) > 0;
 }
 
-bool QuicFramer::AppendStopWaitingFrame(const QuicPacketHeader& header,
-                                        const QuicStopWaitingFrame& frame,
-                                        QuicDataWriter* writer) {
-  QUICHE_DCHECK(!version_.HasIetfInvariantHeader());
-  QUICHE_DCHECK(frame.least_unacked.IsInitialized());
-  QUICHE_DCHECK_GE(header.packet_number, frame.least_unacked);
-  const uint64_t least_unacked_delta =
-      header.packet_number - frame.least_unacked;
-  const uint64_t length_shift = header.packet_number_length * 8;
-
-  if (least_unacked_delta >> length_shift > 0) {
-    QUIC_BUG(quic_bug_10850_86)
-        << "packet_number_length " << header.packet_number_length
-        << " is too small for least_unacked_delta: " << least_unacked_delta
-        << " packet_number:" << header.packet_number
-        << " least_unacked:" << frame.least_unacked
-        << " version:" << version_.transport_version;
-    return false;
-  }
-  if (least_unacked_delta == 0) {
-    return writer->WriteBytesToUInt64(header.packet_number_length,
-                                      least_unacked_delta);
-  }
-  if (!AppendPacketNumber(header.packet_number_length,
-                          QuicPacketNumber(least_unacked_delta), writer)) {
-    QUIC_BUG(quic_bug_10850_87)
-        << " seq failed: " << header.packet_number_length;
-    return false;
-  }
-
-  return true;
-}
-
 bool QuicFramer::AppendIetfAckFrameAndTypeByte(const QuicAckFrame& frame,
                                                QuicDataWriter* writer) {
   uint8_t type = IETF_ACK;
@@ -6279,16 +5845,9 @@
   return false;
 }
 
-bool QuicFramer::IsVersionNegotiation(
-    const QuicPacketHeader& header, bool packet_has_ietf_packet_header) const {
-  if (!packet_has_ietf_packet_header &&
-      perspective_ == Perspective::IS_CLIENT) {
-    return header.version_flag;
-  }
-  if (header.form == IETF_QUIC_SHORT_HEADER_PACKET) {
-    return false;
-  }
-  return header.long_packet_type == VERSION_NEGOTIATION;
+bool QuicFramer::IsVersionNegotiation(const QuicPacketHeader& header) const {
+  return header.form == IETF_QUIC_LONG_HEADER_PACKET &&
+         header.long_packet_type == VERSION_NEGOTIATION;
 }
 
 bool QuicFramer::AppendIetfConnectionCloseFrame(
diff --git a/quiche/quic/core/quic_framer.h b/quiche/quic/core/quic_framer.h
index b93667e..aaf7733 100644
--- a/quiche/quic/core/quic_framer.h
+++ b/quiche/quic/core/quic_framer.h
@@ -85,10 +85,6 @@
   // has been validated or processed.
   virtual void OnPacket() = 0;
 
-  // Called when a public reset packet has been parsed but has not yet
-  // been validated.
-  virtual void OnPublicResetPacket(const QuicPublicResetPacket& packet) = 0;
-
   // Called only when |perspective_| is IS_CLIENT and a version negotiation
   // packet has been parsed.
   virtual void OnVersionNegotiationPacket(
@@ -350,8 +346,7 @@
   // data length provided, but not counting the size of the data payload.
   static size_t GetMinCryptoFrameSize(QuicStreamOffset offset,
                                       QuicPacketLength data_length);
-  static size_t GetMessageFrameSize(QuicTransportVersion version,
-                                    bool last_frame_in_packet,
+  static size_t GetMessageFrameSize(bool last_frame_in_packet,
                                     QuicByteCount length);
   // Size in bytes of all ack frame fields without the missing packets or ack
   // blocks.
@@ -527,8 +522,6 @@
   // If header.version_flag is set, the version in the
   // packet will be set -- but it will be set from version_ not
   // header.versions.
-  bool AppendPacketHeader(const QuicPacketHeader& header,
-                          QuicDataWriter* writer, size_t* length_field_offset);
   bool AppendIetfHeaderTypeByte(const QuicPacketHeader& header,
                                 QuicDataWriter* writer);
   bool AppendIetfPacketHeader(const QuicPacketHeader& header,
@@ -795,18 +788,11 @@
                               uint64_t* full_packet_number,
                               std::vector<char>* associated_data);
 
-  bool ProcessDataPacket(QuicDataReader* reader, QuicPacketHeader* header,
-                         const QuicEncryptedPacket& packet,
-                         char* decrypted_buffer, size_t buffer_length);
-
   bool ProcessIetfDataPacket(QuicDataReader* encrypted_reader,
                              QuicPacketHeader* header,
                              const QuicEncryptedPacket& packet,
                              char* decrypted_buffer, size_t buffer_length);
 
-  bool ProcessPublicResetPacket(QuicDataReader* reader,
-                                const QuicPacketHeader& header);
-
   bool ProcessVersionNegotiationPacket(QuicDataReader* reader,
                                        const QuicPacketHeader& header);
 
@@ -820,15 +806,6 @@
   bool MaybeProcessIetfLength(QuicDataReader* encrypted_reader,
                               QuicPacketHeader* header);
 
-  bool ProcessPublicHeader(QuicDataReader* reader,
-                           bool packet_has_ietf_packet_header,
-                           QuicPacketHeader* header);
-
-  // Processes the unauthenticated portion of the header into |header| from
-  // the current QuicDataReader.  Returns true on success, false on failure.
-  bool ProcessUnauthenticatedHeader(QuicDataReader* encrypted_reader,
-                                    QuicPacketHeader* header);
-
   // Processes the version label in the packet header.
   static bool ProcessVersionLabel(QuicDataReader* reader,
                                   QuicVersionLabel* version_label);
@@ -1063,8 +1040,7 @@
   bool RaiseError(QuicErrorCode error);
 
   // Returns true if |header| indicates a version negotiation packet.
-  bool IsVersionNegotiation(const QuicPacketHeader& header,
-                            bool packet_has_ietf_packet_header) const;
+  bool IsVersionNegotiation(const QuicPacketHeader& header) const;
 
   // Calculates and returns type byte of stream frame.
   uint8_t GetStreamFrameTypeByte(const QuicStreamFrame& frame,
diff --git a/quiche/quic/core/quic_framer_test.cc b/quiche/quic/core/quic_framer_test.cc
index 56f0fbc..48d4001 100644
--- a/quiche/quic/core/quic_framer_test.cc
+++ b/quiche/quic/core/quic_framer_test.cc
@@ -244,11 +244,6 @@
 
   void OnPacket() override {}
 
-  void OnPublicResetPacket(const QuicPublicResetPacket& packet) override {
-    public_reset_packet_ = std::make_unique<QuicPublicResetPacket>((packet));
-    EXPECT_EQ(0u, framer_->current_received_frame_type());
-  }
-
   void OnVersionNegotiationPacket(
       const QuicVersionNegotiationPacket& packet) override {
     version_negotiation_packet_ =
@@ -639,7 +634,6 @@
   bool accept_public_header_;
 
   std::unique_ptr<QuicPacketHeader> header_;
-  std::unique_ptr<QuicPublicResetPacket> public_reset_packet_;
   std::unique_ptr<QuicIetfStatelessResetPacket> stateless_reset_packet_;
   std::unique_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_;
   std::unique_ptr<QuicConnectionId> retry_original_connection_id_;
@@ -1062,16 +1056,6 @@
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   unsigned char packet[kMaxIncomingPacketSize + 1] = {
-    // public flags (8 byte connection_id)
-    0x28,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x78, 0x56, 0x34, 0x12,
-    // private flags
-    0x00,
-  };
-  unsigned char packet46[kMaxIncomingPacketSize + 1] = {
     // type (short header 4 byte packet number)
     0x43,
     // connection_id
@@ -1080,12 +1064,6 @@
     0x78, 0x56, 0x34, 0x12,
   };
   // clang-format on
-  unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
-  if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
-  }
 
   const size_t header_size = GetPacketHeaderSize(
       framer_.transport_version(), kPacket8ByteConnectionId,
@@ -1093,9 +1071,9 @@
       PACKET_4BYTE_PACKET_NUMBER, quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
       quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0);
 
-  memset(p + header_size, 0, kMaxIncomingPacketSize - header_size);
+  memset(packet + header_size, 0, kMaxIncomingPacketSize - header_size);
 
-  QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
+  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
 
   ASSERT_TRUE(visitor_.header_.get());
@@ -1107,68 +1085,9 @@
   EXPECT_EQ("Packet too large.", framer_.detailed_error());
 }
 
-TEST_P(QuicFramerTest, PacketHeader) {
-  if (framer_.version().HasIetfInvariantHeader()) {
-    return;
-  }
-
-  // clang-format off
-  PacketFragments packet = {
-      // public flags (8 byte connection_id)
-      {"Unable to read public flags.",
-       {0x28}},
-      // connection_id
-      {"Unable to read ConnectionId.",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // packet number
-      {"Unable to read packet number.",
-       {0x12, 0x34, 0x56, 0x78}},
-  };
-  // clang-format on
-
-  PacketFragments& fragments = packet;
-
-  std::unique_ptr<QuicEncryptedPacket> encrypted(
-      AssemblePacketFromFragments(fragments));
-
-  EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
-  EXPECT_THAT(framer_.error(), IsError(QUIC_MISSING_PAYLOAD));
-  ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_EQ(FramerTestConnectionId(),
-            visitor_.header_->destination_connection_id);
-  EXPECT_FALSE(visitor_.header_->reset_flag);
-  EXPECT_FALSE(visitor_.header_->version_flag);
-  EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
-
-  CheckFramingBoundaries(fragments, QUIC_INVALID_PACKET_HEADER);
-
-  PacketHeaderFormat format;
-  QuicLongHeaderType long_packet_type = INVALID_PACKET_TYPE;
-  bool version_flag;
-  QuicConnectionId destination_connection_id, source_connection_id;
-  QuicVersionLabel version_label;
-  std::string detailed_error;
-  bool use_length_prefix;
-  absl::optional<absl::string_view> retry_token;
-  ParsedQuicVersion parsed_version = UnsupportedQuicVersion();
-  const QuicErrorCode error_code = QuicFramer::ParsePublicHeaderDispatcher(
-      *encrypted, kQuicDefaultConnectionIdLength, &format, &long_packet_type,
-      &version_flag, &use_length_prefix, &version_label, &parsed_version,
-      &destination_connection_id, &source_connection_id, &retry_token,
-      &detailed_error);
-  EXPECT_FALSE(retry_token.has_value());
-  EXPECT_FALSE(use_length_prefix);
-  EXPECT_THAT(error_code, IsQuicNoError());
-  EXPECT_EQ(GOOGLE_QUIC_PACKET, format);
-  EXPECT_FALSE(version_flag);
-  EXPECT_EQ(kQuicDefaultConnectionIdLength, destination_connection_id.length());
-  EXPECT_EQ(FramerTestConnectionId(), destination_connection_id);
-  EXPECT_EQ(EmptyQuicConnectionId(), source_connection_id);
-}
-
 TEST_P(QuicFramerTest, LongPacketHeader) {
   // clang-format off
-  PacketFragments packet46 = {
+  PacketFragments packet = {
     // type (long header with packet type ZERO_RTT)
     {"Unable to read first byte.",
      {0xD3}},
@@ -1187,14 +1106,13 @@
   };
   // clang-format on
 
-  if (!framer_.version().HasIetfInvariantHeader() ||
-      QuicVersionHasLongHeaderLengths(framer_.transport_version())) {
+  if (QuicVersionHasLongHeaderLengths(framer_.transport_version())) {
     return;
   }
 
   SetDecrypterLevel(ENCRYPTION_ZERO_RTT);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
-      AssemblePacketFromFragments(packet46));
+      AssemblePacketFromFragments(packet));
 
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
   EXPECT_THAT(framer_.error(), IsError(QUIC_MISSING_PAYLOAD));
@@ -1205,7 +1123,7 @@
   EXPECT_TRUE(visitor_.header_->version_flag);
   EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
 
-  CheckFramingBoundaries(packet46, QUIC_INVALID_PACKET_HEADER);
+  CheckFramingBoundaries(packet, QUIC_INVALID_PACKET_HEADER);
 
   PacketHeaderFormat format;
   QuicLongHeaderType long_packet_type = INVALID_PACKET_TYPE;
@@ -1233,10 +1151,6 @@
 }
 
 TEST_P(QuicFramerTest, LongPacketHeaderWithBothConnectionIds) {
-  if (!framer_.version().HasIetfInvariantHeader()) {
-    // This test requires an IETF long header.
-    return;
-  }
   SetDecrypterLevel(ENCRYPTION_ZERO_RTT);
   // clang-format off
   unsigned char packet[] = {
@@ -1337,19 +1251,6 @@
 TEST_P(QuicFramerTest, ParsePublicHeader) {
   // clang-format off
   unsigned char packet[] = {
-    // public flags (version included, 8-byte connection ID,
-    // 4-byte packet number)
-    0x29,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // version
-    QUIC_VERSION_BYTES,
-    // 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,
@@ -1392,9 +1293,6 @@
     ReviseFirstByteByVersion(packet49);
     p = packet49;
     p_length = ABSL_ARRAYSIZE(packet49);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_length = ABSL_ARRAYSIZE(packet46);
   }
 
   uint8_t first_byte = 0x33;
@@ -1412,12 +1310,11 @@
 
   QuicDataReader reader(AsChars(p), p_length);
   const QuicErrorCode parse_error = QuicFramer::ParsePublicHeader(
-      &reader, kQuicDefaultConnectionIdLength,
-      /*ietf_format=*/
-      framer_.version().HasIetfInvariantHeader(), &first_byte, &format,
-      &version_present, &has_length_prefix, &version_label, &parsed_version,
-      &destination_connection_id, &source_connection_id, &long_packet_type,
-      &retry_token_length_length, &retry_token, &detailed_error);
+      &reader, kQuicDefaultConnectionIdLength, /*ietf_format=*/true,
+      &first_byte, &format, &version_present, &has_length_prefix,
+      &version_label, &parsed_version, &destination_connection_id,
+      &source_connection_id, &long_packet_type, &retry_token_length_length,
+      &retry_token, &detailed_error);
   EXPECT_THAT(parse_error, IsQuicNoError());
   EXPECT_EQ("", detailed_error);
   EXPECT_EQ(p[0], first_byte);
@@ -1431,12 +1328,8 @@
   EXPECT_EQ(quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0,
             retry_token_length_length);
   EXPECT_EQ(absl::string_view(), retry_token);
-  if (framer_.version().HasIetfInvariantHeader()) {
-    EXPECT_EQ(IETF_QUIC_LONG_HEADER_PACKET, format);
-    EXPECT_EQ(HANDSHAKE, long_packet_type);
-  } else {
-    EXPECT_EQ(GOOGLE_QUIC_PACKET, format);
-  }
+  EXPECT_EQ(IETF_QUIC_LONG_HEADER_PACKET, format);
+  EXPECT_EQ(HANDSHAKE, long_packet_type);
 }
 
 TEST_P(QuicFramerTest, ParsePublicHeaderProxBadSourceConnectionIdLength) {
@@ -1571,16 +1464,6 @@
 
   // clang-format off
   PacketFragments packet = {
-      // public flags (0 byte connection_id)
-      {"Unable to read public flags.",
-       {0x20}},
-      // 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.",
          {0x43}},
@@ -1602,9 +1485,7 @@
   // clang-format on
 
   PacketFragments& fragments =
-      framer_.version().HasHeaderProtection()
-          ? packet_hp
-          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+      framer_.version().HasHeaderProtection() ? packet_hp : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
@@ -1621,21 +1502,6 @@
   SetDecrypterLevel(ENCRYPTION_ZERO_RTT);
   // clang-format off
   PacketFragments packet = {
-      // public flags (0 byte connection_id)
-      {"Unable to read public flags.",
-       {0x29}},
-      // connection_id
-      {"Unable to read ConnectionId.",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // version tag
-      {"Unable to read protocol version.",
-       {QUIC_VERSION_BYTES}},
-      // 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)
       {"Unable to read first byte.",
@@ -1682,9 +1548,7 @@
 
   ReviseFirstByteByVersion(packet49);
   PacketFragments& fragments =
-      framer_.version().HasLongHeaderLengths()
-          ? packet49
-          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+      framer_.version().HasLongHeaderLengths() ? packet49 : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
@@ -1706,18 +1570,6 @@
 
   // clang-format off
   PacketFragments packet = {
-      // public flags (8 byte connection_id and 4 byte packet number)
-      {"Unable to read public flags.",
-       {0x28}},
-      // connection_id
-      {"Unable to read ConnectionId.",
-       {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.",
        {0x43}},
@@ -1743,9 +1595,7 @@
   // clang-format on
 
   PacketFragments& fragments =
-      framer_.version().HasHeaderProtection()
-          ? packet_hp
-          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+      framer_.version().HasHeaderProtection() ? packet_hp : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
@@ -1766,18 +1616,6 @@
 
   // clang-format off
   PacketFragments packet = {
-      // public flags (8 byte connection_id and 2 byte packet number)
-      {"Unable to read public flags.",
-       {0x18}},
-      // connection_id
-      {"Unable to read ConnectionId.",
-       {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.",
        {0x41}},
@@ -1805,9 +1643,7 @@
   // clang-format on
 
   PacketFragments& fragments =
-      framer_.version().HasHeaderProtection()
-          ? packet_hp
-          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+      framer_.version().HasHeaderProtection() ? packet_hp : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   if (framer_.version().HasHeaderProtection()) {
@@ -1834,18 +1670,6 @@
 
   // clang-format off
   PacketFragments packet = {
-      // public flags (8 byte connection_id and 1 byte packet number)
-      {"Unable to read public flags.",
-       {0x08}},
-      // connection_id
-      {"Unable to read ConnectionId.",
-       {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.",
        {0x40}},
@@ -1874,9 +1698,7 @@
   // clang-format on
 
   PacketFragments& fragments =
-      framer_.version().HasHeaderProtection()
-          ? packet_hp
-          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+      framer_.version().HasHeaderProtection() ? packet_hp : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   if (framer_.version().HasHeaderProtection()) {
@@ -1968,24 +1790,6 @@
   SetDecrypterLevel(ENCRYPTION_ZERO_RTT);
   // clang-format off
   unsigned char packet[] = {
-    // public flags: includes nonce flag
-    0x2C,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // 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,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // 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.
     0xD0,
@@ -2045,9 +1849,6 @@
   if (framer_.version().HasLongHeaderLengths()) {
     p = packet49;
     p_size = ABSL_ARRAYSIZE(packet49);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -2064,21 +1865,6 @@
 TEST_P(QuicFramerTest, LargePublicFlagWithMismatchedVersions) {
   // clang-format off
   unsigned char packet[] = {
-    // public flags (8 byte connection_id, version flag and an unknown flag)
-    0x29,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // version tag
-    'Q', '0', '0', '0',
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (padding frame)
-    0x00,
-    0x00, 0x00, 0x00, 0x00
-  };
-
-  unsigned char packet46[] = {
     // type (long header, ZERO_RTT_PROTECTED, 4-byte packet number)
     0xD3,
     // version tag
@@ -2120,9 +1906,6 @@
   if (framer_.version().HasLongHeaderLengths()) {
     p = packet49;
     p_size = ABSL_ARRAYSIZE(packet49);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
   }
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -2136,33 +1919,6 @@
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x28,
-    // 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,
     // connection_id
@@ -2223,9 +1979,6 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
     p_size = ABSL_ARRAYSIZE(packet_ietf);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -2251,36 +2004,6 @@
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   PacketFragments packet = {
-      // public flags (8 byte connection_id)
-      {"",
-       {0x28}},
-      // 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)
       {"",
        {0x43}},
@@ -2342,9 +2065,8 @@
   // clang-format on
 
   PacketFragments& fragments =
-      VersionHasIetfQuicFrames(framer_.transport_version())
-          ? packet_ietf
-          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+      VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+                                                            : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -2442,17 +2164,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-        // public flags (8 byte connection_id)
-        0x28,
-        // 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,
         // version tag
@@ -2492,9 +2203,6 @@
   if (framer_.version().HasLongHeaderLengths()) {
     p = packet49;
     p_length = ABSL_ARRAYSIZE(packet49);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_length = ABSL_ARRAYSIZE(packet46);
   }
   QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
@@ -2502,108 +2210,17 @@
     EXPECT_THAT(framer_.error(), IsError(QUIC_DECRYPTION_FAILURE));
     EXPECT_EQ("Unable to decrypt ENCRYPTION_ZERO_RTT header protection.",
               framer_.detailed_error());
-  } else if (framer_.version().HasIetfInvariantHeader()) {
+  } else {
     // Cannot read diversification nonce.
     EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_PACKET_HEADER));
     EXPECT_EQ("Unable to read nonce.", framer_.detailed_error());
-  } else {
-    EXPECT_THAT(framer_.error(), IsError(QUIC_DECRYPTION_FAILURE));
   }
 }
 
-TEST_P(QuicFramerTest, StreamFrame3ByteStreamId) {
-  if (framer_.version().HasIetfInvariantHeader()) {
-    // This test is nonsensical for IETF Quic.
-    return;
-  }
-  // clang-format off
-  PacketFragments packet = {
-      // public flags (8 byte connection_id)
-      {"",
-       {0x28}},
-      // 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',  '!'}},
-  };
-  // clang-format on
-
-  PacketFragments& fragments = packet;
-  std::unique_ptr<QuicEncryptedPacket> encrypted(
-      AssemblePacketFromFragments(fragments));
-  EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
-
-  EXPECT_THAT(framer_.error(), IsQuicNoError());
-  ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_TRUE(CheckDecryption(
-      *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
-      kPacket8ByteConnectionId, kPacket0ByteConnectionId));
-
-  ASSERT_EQ(1u, visitor_.stream_frames_.size());
-  EXPECT_EQ(0u, visitor_.ack_frames_.size());
-  // Stream ID should be the last 3 bytes of kStreamId.
-  EXPECT_EQ(0x00FFFFFF & kStreamId, visitor_.stream_frames_[0]->stream_id);
-  EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
-  EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset);
-  CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get());
-
-  CheckFramingBoundaries(fragments, QUIC_INVALID_STREAM_DATA);
-}
-
 TEST_P(QuicFramerTest, StreamFrame2ByteStreamId) {
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   PacketFragments packet = {
-      // public flags (8 byte connection_id)
-      {"",
-       {0x28}},
-      // 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)
       {"",
        {0x43}},
@@ -2665,9 +2282,8 @@
   // clang-format on
 
   PacketFragments& fragments =
-      VersionHasIetfQuicFrames(framer_.transport_version())
-          ? packet_ietf
-          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+      VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+                                                            : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -2693,36 +2309,6 @@
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   PacketFragments packet = {
-      // public flags (8 byte connection_id)
-      {"",
-       {0x28}},
-      // 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)
       {"",
        {0x43}},
@@ -2784,9 +2370,8 @@
   // clang-format on
 
   PacketFragments& fragments =
-      VersionHasIetfQuicFrames(framer_.transport_version())
-          ? packet_ietf
-          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+      VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+                                                            : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -2809,48 +2394,9 @@
 }
 
 TEST_P(QuicFramerTest, StreamFrameWithVersion) {
-  // If IETF frames are in use then we must also have the IETF
-  // header invariants.
-  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
-    QUICHE_DCHECK(framer_.version().HasIetfInvariantHeader());
-  }
-
   SetDecrypterLevel(ENCRYPTION_ZERO_RTT);
   // clang-format off
   PacketFragments packet = {
-      // public flags (version, 8 byte connection_id)
-      {"",
-       {0x29}},
-      // connection_id
-      {"",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // version tag
-      {"",
-       {QUIC_VERSION_BYTES}},
-      // 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)
       {"",
@@ -2986,10 +2532,7 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet_ietf
-          : (framer_.version().HasLongHeaderLengths()
-                 ? packet49
-                 : (framer_.version().HasIetfInvariantHeader() ? packet46
-                                                               : packet));
+          : (framer_.version().HasLongHeaderLengths() ? packet49 : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -3020,29 +2563,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-      // public flags (8 byte connection_id)
-      0x28,
-      // 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',  '!',
-  };
-
-  unsigned char packet46[] = {
       // type (short header, 4 byte packet number)
       0x43,
       // connection_id
@@ -3066,15 +2586,7 @@
   };
   // clang-format on
 
-  unsigned char* p = packet;
-  if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-  }
-  QuicEncryptedPacket encrypted(AsChars(p),
-                                framer_.version().HasIetfInvariantHeader()
-                                    ? ABSL_ARRAYSIZE(packet46)
-                                    : ABSL_ARRAYSIZE(packet),
-                                false);
+  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -3092,13 +2604,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x28,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-  };
-
-  unsigned char packet46[] = {
     // type (short header, 1 byte packet number)
     0x40,
     // connection_id
@@ -3108,12 +2613,7 @@
   };
   // clang-format on
 
-  QuicEncryptedPacket encrypted(
-      framer_.version().HasIetfInvariantHeader() ? AsChars(packet46)
-                                                 : AsChars(packet),
-      framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
-                                                 : ABSL_ARRAYSIZE(packet),
-      false);
+  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -3125,34 +2625,6 @@
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   PacketFragments packet = {
-      // public flags (8 byte connection_id)
-      {"",
-       {0x2C}},
-      // 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)
       {"",
        {0x43}},
@@ -3217,9 +2689,8 @@
   // clang-format on
 
   PacketFragments& fragments =
-      VersionHasIetfQuicFrames(framer_.transport_version())
-          ? packet_ietf
-          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+      VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+                                                            : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -3246,34 +2717,6 @@
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   PacketFragments packet = {
-      // public flags (8 byte connection_id)
-      {"",
-       {0x2C}},
-      // 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)
       {"",
        {0x43}},
@@ -3330,9 +2773,8 @@
   // clang-format on
 
   PacketFragments& fragments =
-      VersionHasIetfQuicFrames(framer_.transport_version())
-          ? packet_ietf
-          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+      VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+                                                            : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
@@ -3633,44 +3075,6 @@
 
   // clang-format off
   PacketFragments packet = {
-      // public flags (8 byte connection_id)
-      {"",
-       { 0x2C }},
-      // 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)
       {"",
        { 0x43 }},
@@ -3709,11 +3113,8 @@
   };
 
   // clang-format on
-  PacketFragments& fragments =
-      framer_.version().HasIetfInvariantHeader() ? packet46 : packet;
-
   std::unique_ptr<QuicEncryptedPacket> encrypted(
-      AssemblePacketFromFragments(fragments));
+      AssemblePacketFromFragments(packet));
 
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
   EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_ACK_DATA));
@@ -3726,41 +3127,13 @@
   EXPECT_EQ(0u, visitor_.stream_frames_.size());
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
 
-  CheckFramingBoundaries(fragments, QUIC_INVALID_ACK_DATA);
+  CheckFramingBoundaries(packet, QUIC_INVALID_ACK_DATA);
 }
 
 TEST_P(QuicFramerTest, AckFrameOneAckBlockMaxLength) {
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   PacketFragments packet = {
-      // public flags (8 byte connection_id)
-      {"",
-       {0x2C}},
-      // connection_id
-      {"",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // packet number
-      {"",
-       {0x12, 0x34, 0x56, 0x78}},
-      // 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)
       {"",
        {0x43}},
@@ -3817,9 +3190,8 @@
   // clang-format on
 
   PacketFragments& fragments =
-      VersionHasIetfQuicFrames(framer_.transport_version())
-          ? packet_ietf
-          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+      VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+                                                            : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -3845,74 +3217,6 @@
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   PacketFragments packet = {
-      // public flags (8 byte connection_id)
-      {"",
-       { 0x2C }},
-      // 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)
       {"",
        { 0x43 }},
@@ -4050,9 +3354,8 @@
 
   // clang-format on
   PacketFragments& fragments =
-      VersionHasIetfQuicFrames(framer_.transport_version())
-          ? packet_ietf
-          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+      VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+                                                            : packet;
 
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
@@ -4403,31 +3706,6 @@
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   unsigned char packet[] = {
-      // public flags (8 byte connection_id)
-      0x28,
-      // 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,
       // connection_id
@@ -4456,9 +3734,7 @@
     // ACK Timestamp is not a feature of IETF QUIC.
     return;
   }
-  QuicEncryptedPacket encrypted(
-      AsChars(framer_.version().HasIetfInvariantHeader() ? packet46 : packet),
-      ABSL_ARRAYSIZE(packet), false);
+  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_TRUE(absl::StartsWith(framer_.detailed_error(),
                                "delta_from_largest_observed too high"));
@@ -4468,35 +3744,6 @@
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   unsigned char packet[] = {
-      // public flags (8 byte connection_id)
-      0x28,
-      // 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,
       // connection_id
@@ -4529,9 +3776,7 @@
     // ACK Timestamp is not a feature of IETF QUIC.
     return;
   }
-  QuicEncryptedPacket encrypted(
-      AsChars(framer_.version().HasIetfInvariantHeader() ? packet46 : packet),
-      ABSL_ARRAYSIZE(packet), false);
+  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_TRUE(absl::StartsWith(framer_.detailed_error(),
                                "delta_from_largest_observed too high"));
@@ -4545,24 +3790,6 @@
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   PacketFragments packet = {
-      // public flags (8 byte connection_id)
-      {"",
-       {0x2C}},
-      // 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)
       {"",
        {0x43}},
@@ -4581,11 +3808,8 @@
   };
   // clang-format on
 
-  PacketFragments& fragments =
-      framer_.version().HasIetfInvariantHeader() ? packet46 : packet;
-
   std::unique_ptr<QuicEncryptedPacket> encrypted(
-      AssemblePacketFromFragments(fragments));
+      AssemblePacketFromFragments(packet));
 
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
   EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -4599,32 +3823,17 @@
   const QuicStopWaitingFrame& frame = *visitor_.stop_waiting_frames_[0];
   EXPECT_EQ(kLeastUnacked, frame.least_unacked);
 
-  CheckFramingBoundaries(fragments, QUIC_INVALID_STOP_WAITING_DATA);
+  CheckFramingBoundaries(packet, QUIC_INVALID_STOP_WAITING_DATA);
 }
 
 TEST_P(QuicFramerTest, InvalidNewStopWaitingFrame) {
   // The Stop Waiting frame is not in IETF QUIC
-  if (VersionHasIetfQuicFrames(version_.transport_version) &&
-      framer_.version().HasIetfInvariantHeader()) {
+  if (VersionHasIetfQuicFrames(version_.transport_version)) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x2C,
-    // 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.
-    0x13, 0x34, 0x56, 0x78,
-    0x9A, 0xA8,
-  };
-
-  unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
     // connection_id
@@ -4638,11 +3847,7 @@
   };
   // clang-format on
 
-  QuicEncryptedPacket encrypted(
-      AsChars(framer_.version().HasIetfInvariantHeader() ? packet46 : packet),
-      framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
-                                                 : ABSL_ARRAYSIZE(packet),
-      false);
+  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_STOP_WAITING_DATA));
   EXPECT_EQ("Invalid unacked delta.", framer_.detailed_error());
@@ -4652,31 +3857,6 @@
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   PacketFragments packet = {
-      // public flags (8 byte connection_id)
-      {"",
-       {0x28}},
-      // 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 QUIC_STREAM_CANCELLED
-      {"Unable to read rst stream error code.",
-       {0x00, 0x00, 0x00, 0x06}}
-  };
-
-  PacketFragments packet46 = {
       // type (short header, 4 byte packet number)
       {"",
        {0x43}},
@@ -4728,9 +3908,8 @@
   // clang-format on
 
   PacketFragments& fragments =
-      VersionHasIetfQuicFrames(framer_.transport_version())
-          ? packet_ietf
-          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+      VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+                                                            : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -4751,34 +3930,6 @@
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   PacketFragments packet = {
-      // public flags (8 byte connection_id)
-      {"",
-       {0x28}},
-      // 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)
       {"",
        {0x43}},
@@ -4839,9 +3990,8 @@
   // clang-format on
 
   PacketFragments& fragments =
-      VersionHasIetfQuicFrames(framer_.transport_version())
-          ? packet_ietf
-          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+      VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+                                                            : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -4876,34 +4026,6 @@
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   PacketFragments packet = {
-      // public flags (8 byte connection_id)
-      {"",
-       {0x28}},
-      // connection_id
-      {"",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // packet number
-      {"",
-       {0x12, 0x34, 0x56, 0x78}},
-      // frame type (connection close frame)
-      {"",
-       {0x02}},
-      // error code larger than QUIC_LAST_ERROR
-      {"Unable to read connection close error code.",
-       {0x00, 0x00, 0xC0, 0xDE}},
-      {"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)
       {"",
        {0x43}},
@@ -4964,9 +4086,8 @@
   // clang-format on
 
   PacketFragments& fragments =
-      VersionHasIetfQuicFrames(framer_.transport_version())
-          ? packet_ietf
-          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+      VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+                                                            : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -5004,35 +4125,6 @@
 
   // clang-format off
   PacketFragments packet = {
-    // public flags (8 byte connection_id)
-    {"",
-     {0x28}},
-    // 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, 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)
     {"",
      {0x43}},
@@ -5094,9 +4186,8 @@
   // clang-format on
 
   PacketFragments& fragments =
-      VersionHasIetfQuicFrames(framer_.transport_version())
-          ? packet_ietf
-          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+      VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+                                                            : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -5260,38 +4351,6 @@
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   PacketFragments packet = {
-      // public flags (8 byte connection_id)
-      {"",
-       {0x28}},
-      // 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)
       {"",
        {0x43}},
@@ -5324,10 +4383,8 @@
   };
   // clang-format on
 
-  PacketFragments& fragments =
-      framer_.version().HasIetfInvariantHeader() ? packet46 : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
-      AssemblePacketFromFragments(fragments));
+      AssemblePacketFromFragments(packet));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
   EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -5340,7 +4397,7 @@
   EXPECT_EQ(0x9u, visitor_.goaway_frame_.error_code);
   EXPECT_EQ("because I can", visitor_.goaway_frame_.reason_phrase);
 
-  CheckFramingBoundaries(fragments, QUIC_INVALID_GOAWAY_DATA);
+  CheckFramingBoundaries(packet, QUIC_INVALID_GOAWAY_DATA);
 }
 
 TEST_P(QuicFramerTest, GoAwayFrameWithUnknownErrorCode) {
@@ -5351,38 +4408,6 @@
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   PacketFragments packet = {
-      // public flags (8 byte connection_id)
-      {"",
-       {0x28}},
-      // connection_id
-      {"",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // packet number
-      {"",
-       {0x12, 0x34, 0x56, 0x78}},
-      // frame type (go away frame)
-      {"",
-       {0x03}},
-      // error code larger than QUIC_LAST_ERROR
-      {"Unable to read go away error code.",
-       {0x00, 0x00, 0xC0, 0xDE}},
-      // 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)
       {"",
        {0x43}},
@@ -5415,10 +4440,8 @@
   };
   // clang-format on
 
-  PacketFragments& fragments =
-      framer_.version().HasIetfInvariantHeader() ? packet46 : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
-      AssemblePacketFromFragments(fragments));
+      AssemblePacketFromFragments(packet));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
   EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -5431,7 +4454,7 @@
   EXPECT_EQ(0xC0DE, visitor_.goaway_frame_.error_code);
   EXPECT_EQ("because I can", visitor_.goaway_frame_.reason_phrase);
 
-  CheckFramingBoundaries(fragments, QUIC_INVALID_GOAWAY_DATA);
+  CheckFramingBoundaries(packet, QUIC_INVALID_GOAWAY_DATA);
 }
 
 TEST_P(QuicFramerTest, WindowUpdateFrame) {
@@ -5443,28 +4466,6 @@
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   PacketFragments packet = {
-      // public flags (8 byte connection_id)
-      {"",
-       {0x28}},
-      // 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)
       {"",
        {0x43}},
@@ -5488,10 +4489,8 @@
 
   // clang-format on
 
-  PacketFragments& fragments =
-      framer_.version().HasIetfInvariantHeader() ? packet46 : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
-      AssemblePacketFromFragments(fragments));
+      AssemblePacketFromFragments(packet));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
   EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -5503,7 +4502,7 @@
   EXPECT_EQ(kStreamId, visitor_.window_update_frame_.stream_id);
   EXPECT_EQ(kStreamOffset, visitor_.window_update_frame_.max_data);
 
-  CheckFramingBoundaries(fragments, QUIC_INVALID_WINDOW_UPDATE_DATA);
+  CheckFramingBoundaries(packet, QUIC_INVALID_WINDOW_UPDATE_DATA);
 }
 
 TEST_P(QuicFramerTest, MaxDataFrame) {
@@ -5600,24 +4599,6 @@
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   PacketFragments packet = {
-      // public flags (8 byte connection_id)
-      {"",
-       {0x28}},
-      // 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)
       {"",
        {0x43}},
@@ -5658,9 +4639,8 @@
   // clang-format on
 
   PacketFragments& fragments =
-      VersionHasIetfQuicFrames(framer_.transport_version())
-          ? packet_ietf
-          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
+      VersionHasIetfQuicFrames(framer_.transport_version()) ? packet_ietf
+                                                            : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -5689,18 +4669,6 @@
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   unsigned char packet[] = {
-     // public flags (8 byte connection_id)
-     0x28,
-     // connection_id
-     0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-     // packet number
-     0x12, 0x34, 0x56, 0x78,
-
-     // frame type (ping frame)
-     0x07,
-    };
-
-  unsigned char packet46[] = {
      // type (short header, 4 byte packet number)
      0x43,
      // connection_id
@@ -5728,13 +4696,10 @@
   QuicEncryptedPacket encrypted(
       AsChars(VersionHasIetfQuicFrames(framer_.transport_version())
                   ? packet_ietf
-                  : (framer_.version().HasIetfInvariantHeader() ? packet46
-                                                                : packet)),
+                  : packet),
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? ABSL_ARRAYSIZE(packet_ietf)
-          : (framer_.version().HasIetfInvariantHeader()
-                 ? ABSL_ARRAYSIZE(packet46)
-                 : ABSL_ARRAYSIZE(packet)),
+          : ABSL_ARRAYSIZE(packet),
       false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
@@ -5827,12 +4792,9 @@
 }
 
 TEST_P(QuicFramerTest, MessageFrame) {
-  if (!VersionSupportsMessageFrames(framer_.transport_version())) {
-    return;
-  }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
-  PacketFragments packet46 = {
+  PacketFragments packet = {
        // type (short header, 4 byte packet number)
        {"",
         {0x43}},
@@ -5890,7 +4852,7 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     encrypted = AssemblePacketFromFragments(packet_ietf);
   } else {
-    encrypted = AssemblePacketFromFragments(packet46);
+    encrypted = AssemblePacketFromFragments(packet);
   }
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
 
@@ -5907,216 +4869,10 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     CheckFramingBoundaries(packet_ietf, QUIC_INVALID_MESSAGE_DATA);
   } else {
-    CheckFramingBoundaries(packet46, QUIC_INVALID_MESSAGE_DATA);
+    CheckFramingBoundaries(packet, QUIC_INVALID_MESSAGE_DATA);
   }
 }
 
-TEST_P(QuicFramerTest, PublicResetPacketV33) {
-  // clang-format off
-  PacketFragments packet = {
-      // public flags (public reset, 8 byte connection_id)
-      {"",
-       {0x0A}},
-      // connection_id
-      {"",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      {"Unable to read reset message.",
-       {
-         // message tag (kPRST)
-         'P', 'R', 'S', 'T',
-         // num_entries (2) + padding
-         0x02, 0x00, 0x00, 0x00,
-         // tag kRNON
-         'R', 'N', 'O', 'N',
-         // end offset 8
-         0x08, 0x00, 0x00, 0x00,
-         // tag kRSEQ
-         'R', 'S', 'E', 'Q',
-         // end offset 16
-         0x10, 0x00, 0x00, 0x00,
-         // nonce proof
-         0x89, 0x67, 0x45, 0x23,
-         0x01, 0xEF, 0xCD, 0xAB,
-         // rejected packet number
-         0xBC, 0x9A, 0x78, 0x56,
-         0x34, 0x12, 0x00, 0x00,
-       }
-      }
-  };
-  // clang-format on
-  if (framer_.version().HasIetfInvariantHeader()) {
-    return;
-  }
-
-  std::unique_ptr<QuicEncryptedPacket> encrypted(
-      AssemblePacketFromFragments(packet));
-  EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
-  ASSERT_THAT(framer_.error(), IsQuicNoError());
-  ASSERT_TRUE(visitor_.public_reset_packet_.get());
-  EXPECT_EQ(FramerTestConnectionId(),
-            visitor_.public_reset_packet_->connection_id);
-  EXPECT_EQ(kNonceProof, visitor_.public_reset_packet_->nonce_proof);
-  EXPECT_EQ(
-      IpAddressFamily::IP_UNSPEC,
-      visitor_.public_reset_packet_->client_address.host().address_family());
-
-  CheckFramingBoundaries(packet, QUIC_INVALID_PUBLIC_RST_PACKET);
-}
-
-TEST_P(QuicFramerTest, PublicResetPacket) {
-  QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
-
-  // clang-format off
-  PacketFragments packet = {
-      // public flags (public reset, 8 byte connection_id)
-      {"",
-       {0x0E}},
-      // connection_id
-      {"",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      {"Unable to read reset message.",
-       {
-         // message tag (kPRST)
-         'P', 'R', 'S', 'T',
-         // num_entries (2) + padding
-         0x02, 0x00, 0x00, 0x00,
-         // tag kRNON
-         'R', 'N', 'O', 'N',
-         // end offset 8
-         0x08, 0x00, 0x00, 0x00,
-         // tag kRSEQ
-         'R', 'S', 'E', 'Q',
-         // end offset 16
-         0x10, 0x00, 0x00, 0x00,
-         // nonce proof
-         0x89, 0x67, 0x45, 0x23,
-         0x01, 0xEF, 0xCD, 0xAB,
-         // rejected packet number
-         0xBC, 0x9A, 0x78, 0x56,
-         0x34, 0x12, 0x00, 0x00,
-       }
-      }
-  };
-  // clang-format on
-
-  if (framer_.version().HasIetfInvariantHeader()) {
-    return;
-  }
-
-  std::unique_ptr<QuicEncryptedPacket> encrypted(
-      AssemblePacketFromFragments(packet));
-  EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
-  ASSERT_THAT(framer_.error(), IsQuicNoError());
-  ASSERT_TRUE(visitor_.public_reset_packet_.get());
-  EXPECT_EQ(FramerTestConnectionId(),
-            visitor_.public_reset_packet_->connection_id);
-  EXPECT_EQ(kNonceProof, visitor_.public_reset_packet_->nonce_proof);
-  EXPECT_EQ(
-      IpAddressFamily::IP_UNSPEC,
-      visitor_.public_reset_packet_->client_address.host().address_family());
-
-  CheckFramingBoundaries(packet, QUIC_INVALID_PUBLIC_RST_PACKET);
-}
-
-TEST_P(QuicFramerTest, PublicResetPacketWithTrailingJunk) {
-  // clang-format off
-  unsigned char packet[] = {
-    // public flags (public reset, 8 byte connection_id)
-    0x0A,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // message tag (kPRST)
-    'P', 'R', 'S', 'T',
-    // num_entries (2) + padding
-    0x02, 0x00, 0x00, 0x00,
-    // tag kRNON
-    'R', 'N', 'O', 'N',
-    // end offset 8
-    0x08, 0x00, 0x00, 0x00,
-    // tag kRSEQ
-    'R', 'S', 'E', 'Q',
-    // end offset 16
-    0x10, 0x00, 0x00, 0x00,
-    // nonce proof
-    0x89, 0x67, 0x45, 0x23,
-    0x01, 0xEF, 0xCD, 0xAB,
-    // rejected packet number
-    0xBC, 0x9A, 0x78, 0x56,
-    0x34, 0x12, 0x00, 0x00,
-    // trailing junk
-    'j', 'u', 'n', 'k',
-  };
-  // clang-format on
-  if (framer_.version().HasIetfInvariantHeader()) {
-    return;
-  }
-
-  QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
-  EXPECT_FALSE(framer_.ProcessPacket(encrypted));
-  ASSERT_THAT(framer_.error(), IsError(QUIC_INVALID_PUBLIC_RST_PACKET));
-  EXPECT_EQ("Unable to read reset message.", framer_.detailed_error());
-}
-
-TEST_P(QuicFramerTest, PublicResetPacketWithClientAddress) {
-  // clang-format off
-  PacketFragments packet = {
-      // public flags (public reset, 8 byte connection_id)
-      {"",
-       {0x0A}},
-      // connection_id
-      {"",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      {"Unable to read reset message.",
-       {
-         // message tag (kPRST)
-         'P', 'R', 'S', 'T',
-         // num_entries (2) + padding
-         0x03, 0x00, 0x00, 0x00,
-         // tag kRNON
-         'R', 'N', 'O', 'N',
-         // end offset 8
-         0x08, 0x00, 0x00, 0x00,
-         // tag kRSEQ
-         'R', 'S', 'E', 'Q',
-         // end offset 16
-         0x10, 0x00, 0x00, 0x00,
-         // tag kCADR
-         'C', 'A', 'D', 'R',
-         // end offset 24
-         0x18, 0x00, 0x00, 0x00,
-         // nonce proof
-         0x89, 0x67, 0x45, 0x23,
-         0x01, 0xEF, 0xCD, 0xAB,
-         // rejected packet number
-         0xBC, 0x9A, 0x78, 0x56,
-         0x34, 0x12, 0x00, 0x00,
-         // client address: 4.31.198.44:443
-         0x02, 0x00,
-         0x04, 0x1F, 0xC6, 0x2C,
-         0xBB, 0x01,
-       }
-      }
-  };
-  // clang-format on
-  if (framer_.version().HasIetfInvariantHeader()) {
-    return;
-  }
-
-  std::unique_ptr<QuicEncryptedPacket> encrypted(
-      AssemblePacketFromFragments(packet));
-  EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
-  ASSERT_THAT(framer_.error(), IsQuicNoError());
-  ASSERT_TRUE(visitor_.public_reset_packet_.get());
-  EXPECT_EQ(FramerTestConnectionId(),
-            visitor_.public_reset_packet_->connection_id);
-  EXPECT_EQ(kNonceProof, visitor_.public_reset_packet_->nonce_proof);
-  EXPECT_EQ("4.31.198.44",
-            visitor_.public_reset_packet_->client_address.host().ToString());
-  EXPECT_EQ(443, visitor_.public_reset_packet_->client_address.port());
-
-  CheckFramingBoundaries(packet, QUIC_INVALID_PUBLIC_RST_PACKET);
-}
-
 TEST_P(QuicFramerTest, IetfStatelessResetPacket) {
   // clang-format off
   unsigned char packet[] = {
@@ -6132,9 +4888,6 @@
       0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
   };
   // clang-format on
-  if (!framer_.version().HasIetfInvariantHeader()) {
-    return;
-  }
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
   QuicFramerPeer::SetLastSerializedServerConnectionId(&framer_,
                                                       TestConnectionId(0x33));
@@ -6175,9 +4928,6 @@
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   };
   // clang-format on
-  if (!framer_.version().HasIetfInvariantHeader()) {
-    return;
-  }
   QuicFramerPeer::SetLastSerializedServerConnectionId(&framer_,
                                                       TestConnectionId(0x33));
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
@@ -6204,19 +4954,6 @@
 TEST_P(QuicFramerTest, VersionNegotiationPacketClient) {
   // clang-format off
   PacketFragments packet = {
-      // public flags (version, 8 byte connection_id)
-      {"",
-       {0x29}},
-      // connection_id
-      {"",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // version tag
-      {"Unable to read supported version in negotiation.",
-       {QUIC_VERSION_BYTES,
-        'Q', '2', '.', '0'}},
-  };
-
-  PacketFragments packet46 = {
       // type (long header)
       {"",
        {0x8F}},
@@ -6258,9 +4995,7 @@
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
 
   PacketFragments& fragments =
-      framer_.version().HasLongHeaderLengths()     ? packet49
-      : framer_.version().HasIetfInvariantHeader() ? packet46
-                                                   : packet;
+      framer_.version().HasLongHeaderLengths() ? packet49 : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -6279,10 +5014,6 @@
 }
 
 TEST_P(QuicFramerTest, VersionNegotiationPacketServer) {
-  if (!framer_.version().HasIetfInvariantHeader()) {
-    return;
-  }
-
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_SERVER);
   // clang-format off
   unsigned char packet[] = {
@@ -6330,45 +5061,6 @@
   EXPECT_FALSE(visitor_.version_negotiation_packet_.get());
 }
 
-TEST_P(QuicFramerTest, OldVersionNegotiationPacket) {
-  // clang-format off
-  PacketFragments packet = {
-      // public flags (version, 8 byte connection_id)
-      {"",
-       {0x2D}},
-      // connection_id
-      {"",
-       {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}},
-      // version tag
-      {"Unable to read supported version in negotiation.",
-       {QUIC_VERSION_BYTES,
-        'Q', '2', '.', '0'}},
-  };
-  // clang-format on
-
-  if (framer_.version().HasIetfInvariantHeader()) {
-    return;
-  }
-
-  QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
-
-  std::unique_ptr<QuicEncryptedPacket> encrypted(
-      AssemblePacketFromFragments(packet));
-  EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
-  ASSERT_THAT(framer_.error(), IsQuicNoError());
-  ASSERT_TRUE(visitor_.version_negotiation_packet_.get());
-  EXPECT_EQ(1u, visitor_.version_negotiation_packet_->versions.size());
-  EXPECT_EQ(GetParam(), visitor_.version_negotiation_packet_->versions[0]);
-
-  // Remove the last version from the packet so that every truncated
-  // version of the packet is invalid, otherwise checking boundaries
-  // is annoyingly complicated.
-  for (size_t i = 0; i < 4; ++i) {
-    packet.back().fragment.pop_back();
-  }
-  CheckFramingBoundaries(packet, QUIC_INVALID_VERSION_NEGOTIATION_PACKET);
-}
-
 TEST_P(QuicFramerTest, ParseIetfRetryPacket) {
   if (!framer_.version().SupportsRetry()) {
     return;
@@ -6511,19 +5203,6 @@
 
   // clang-format off
   unsigned char packet[kMaxOutgoingPacketSize] = {
-    // public flags (8 byte connection_id)
-    0x2C,
-    // 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,
     // connection_id
@@ -6553,8 +5232,6 @@
   unsigned char* p = packet;
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
   }
 
   uint64_t header_size = GetPacketHeaderSize(
@@ -6569,8 +5246,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p),
-      framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
-                                                 : ABSL_ARRAYSIZE(packet));
+      ABSL_ARRAYSIZE(packet));
 }
 
 TEST_P(QuicFramerTest, BuildStreamFramePacketWithNewPaddingFrame) {
@@ -6588,33 +5264,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x2C,
-    // 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,
     // connection_id
@@ -6677,9 +5326,6 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
     p_size = ABSL_ARRAYSIZE(packet_ietf);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
   }
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
 
@@ -6700,19 +5346,6 @@
 
   // clang-format off
   unsigned char packet[kMaxOutgoingPacketSize] = {
-    // public flags (8 byte connection_id and 4 byte packet number)
-    0x2C,
-    // 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,
     // connection_id
@@ -6742,8 +5375,6 @@
   unsigned char* p = packet;
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
   }
 
   uint64_t header_size = GetPacketHeaderSize(
@@ -6758,8 +5389,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p),
-      framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
-                                                 : ABSL_ARRAYSIZE(packet));
+      ABSL_ARRAYSIZE(packet));
 }
 
 TEST_P(QuicFramerTest, Build2ByteSequenceNumberPaddingFramePacket) {
@@ -6775,19 +5405,6 @@
 
   // clang-format off
   unsigned char packet[kMaxOutgoingPacketSize] = {
-    // public flags (8 byte connection_id and 2 byte packet number)
-    0x1C,
-    // 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,
     // connection_id
@@ -6817,8 +5434,6 @@
   unsigned char* p = packet;
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
   }
 
   uint64_t header_size = GetPacketHeaderSize(
@@ -6833,8 +5448,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p),
-      framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
-                                                 : ABSL_ARRAYSIZE(packet));
+      ABSL_ARRAYSIZE(packet));
 }
 
 TEST_P(QuicFramerTest, Build1ByteSequenceNumberPaddingFramePacket) {
@@ -6850,19 +5464,6 @@
 
   // clang-format off
   unsigned char packet[kMaxOutgoingPacketSize] = {
-    // public flags (8 byte connection_id and 1 byte packet number)
-    0x0C,
-    // 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,
     // connection_id
@@ -6892,8 +5493,6 @@
   unsigned char* p = packet;
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
   }
 
   uint64_t header_size = GetPacketHeaderSize(
@@ -6908,8 +5507,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p),
-      framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
-                                                 : ABSL_ARRAYSIZE(packet));
+      ABSL_ARRAYSIZE(packet));
 }
 
 TEST_P(QuicFramerTest, BuildStreamFramePacket) {
@@ -6930,27 +5528,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x2C,
-    // 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,
     // connection_id
@@ -7001,9 +5578,6 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
     p_size = ABSL_ARRAYSIZE(packet_ietf);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
   }
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p), p_size);
@@ -7014,9 +5588,7 @@
   header.destination_connection_id = FramerTestConnectionId();
   header.reset_flag = false;
   header.version_flag = true;
-  if (framer_.version().HasIetfInvariantHeader()) {
-    header.long_packet_type = ZERO_RTT_PROTECTED;
-  }
+  header.long_packet_type = ZERO_RTT_PROTECTED;
   header.packet_number = kPacketNumber;
   if (QuicVersionHasLongHeaderLengths(framer_.transport_version())) {
     header.length_length = quiche::VARIABLE_LENGTH_INTEGER_LENGTH_2;
@@ -7028,26 +5600,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-      // public flags (version, 8 byte connection_id)
-      0x2D,
-      // connection_id
-      0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-      // version tag
-      QUIC_VERSION_BYTES,
-      // 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,
       // version tag
@@ -7135,9 +5687,6 @@
   } else if (framer_.version().HasLongHeaderLengths()) {
     p = packet49;
     p_size = ABSL_ARRAYSIZE(packet49);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
   }
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p), p_size);
@@ -7307,7 +5856,7 @@
   CheckFramingBoundaries(fragments, QUIC_INVALID_FRAME_DATA);
 }
 
-TEST_P(QuicFramerTest, BuildVersionNegotiationPacket) {
+TEST_P(QuicFramerTest, BuildOldVersionNegotiationPacket) {
   SetQuicFlag(quic_disable_version_negotiation_grease_randomness, true);
   // clang-format off
   unsigned char packet[] = {
@@ -7319,7 +5868,21 @@
       0xDA, 0x5A, 0x3A, 0x3A,
       QUIC_VERSION_BYTES,
   };
-  unsigned char packet46[] = {
+  QuicConnectionId connection_id = FramerTestConnectionId();
+  std::unique_ptr<QuicEncryptedPacket> data(
+      QuicFramer::BuildVersionNegotiationPacket(
+          connection_id, EmptyQuicConnectionId(), /*ietf_quic=*/false,
+          /*use_length_prefix=*/false,
+          SupportedVersions(GetParam())));
+  quiche::test::CompareCharArraysWithHexError(
+      "constructed packet", data->data(), data->length(), AsChars(packet),
+      ABSL_ARRAYSIZE(packet));
+}
+
+TEST_P(QuicFramerTest, BuildVersionNegotiationPacket) {
+  SetQuicFlag(quic_disable_version_negotiation_grease_randomness, true);
+  // clang-format off
+  unsigned char packet[] = {
       // type (long header)
       0xC0,
       // version tag
@@ -7353,16 +5916,12 @@
   if (framer_.version().HasLongHeaderLengths()) {
     p = packet49;
     p_size = ABSL_ARRAYSIZE(packet49);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
   }
 
   QuicConnectionId connection_id = FramerTestConnectionId();
   std::unique_ptr<QuicEncryptedPacket> data(
       QuicFramer::BuildVersionNegotiationPacket(
-          connection_id, EmptyQuicConnectionId(),
-          framer_.version().HasIetfInvariantHeader(),
+          connection_id, EmptyQuicConnectionId(), /*ietf_quic=*/true,
           framer_.version().HasLengthPrefixedConnectionIds(),
           SupportedVersions(GetParam())));
   quiche::test::CompareCharArraysWithHexError(
@@ -7421,27 +5980,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-      // public flags (8 byte connection_id)
-      0x2C,
-      // 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,
       // connection_id
@@ -7487,9 +6025,6 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
     p_size = ABSL_ARRAYSIZE(packet_ietf);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8213,27 +6748,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-      // public flags (8 byte connection_id)
-      0x2C,
-      // 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,
       // connection_id
@@ -8280,9 +6794,6 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
     p_size = ABSL_ARRAYSIZE(packet_ietf);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8311,45 +6822,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-      // public flags (8 byte connection_id)
-      0x2C,
-      // 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,
       // connection_id
@@ -8428,9 +6900,6 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
     p_size = ABSL_ARRAYSIZE(packet_ietf);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8462,99 +6931,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-      // public flags (8 byte connection_id)
-      0x2C,
-      // 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,
       // connection_id
@@ -8737,9 +7113,6 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
     p_size = ABSL_ARRAYSIZE(packet_ietf);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -8749,47 +7122,6 @@
       "constructed packet", data->data(), data->length(), AsChars(p), p_size);
 }
 
-TEST_P(QuicFramerTest, BuildNewStopWaitingPacket) {
-  if (framer_.version().HasIetfInvariantHeader()) {
-    return;
-  }
-  QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
-  QuicPacketHeader header;
-  header.destination_connection_id = FramerTestConnectionId();
-  header.reset_flag = false;
-  header.version_flag = false;
-  header.packet_number = kPacketNumber;
-
-  QuicStopWaitingFrame stop_waiting_frame;
-  stop_waiting_frame.least_unacked = kLeastUnacked;
-
-  QuicFrames frames = {QuicFrame(stop_waiting_frame)};
-
-  // clang-format off
-  unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x2C,
-    // 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.
-    0x00, 0x00, 0x00, 0x08,
-  };
-
-  // clang-format on
-
-  std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
-  ASSERT_TRUE(data != nullptr);
-
-  quiche::test::CompareCharArraysWithHexError(
-      "constructed packet", data->data(), data->length(), AsChars(packet),
-      ABSL_ARRAYSIZE(packet));
-}
-
 TEST_P(QuicFramerTest, BuildRstFramePacketQuic) {
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
   QuicPacketHeader header;
@@ -8809,25 +7141,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x2C,
-    // 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,
     // connection_id
@@ -8875,9 +7188,6 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
     p_size = ABSL_ARRAYSIZE(packet_ietf);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
   }
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
 
@@ -8900,27 +7210,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x2C,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (connection close frame)
-    0x02,
-    // error code
-    0x00, 0x00, 0x00, 0x01,
-    // 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,
     // connection_id
@@ -8970,9 +7259,6 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
     p_size = ABSL_ARRAYSIZE(packet_ietf);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -9004,27 +7290,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x2C,
-    // 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,
     // connection_id
@@ -9076,9 +7341,6 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
     p_size = ABSL_ARRAYSIZE(packet_ietf);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -9103,55 +7365,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x2C,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (connection close frame)
-    0x02,
-    // error code
-    0x00, 0x00, 0x00, 0x01,
-    // 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,
     // connection_id
@@ -9257,9 +7470,6 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
     p_size = ABSL_ARRAYSIZE(packet_ietf);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -9422,29 +7632,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x2C,
-    // 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,
     // connection_id
@@ -9468,19 +7655,12 @@
   };
 
   // clang-format on
-
-  unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
-  if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
-  }
-
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
   quiche::test::CompareCharArraysWithHexError(
-      "constructed packet", data->data(), data->length(), AsChars(p), p_size);
+      "constructed packet", data->data(), data->length(), AsChars(packet),
+      ABSL_ARRAYSIZE(packet));
 }
 
 TEST_P(QuicFramerTest, BuildTruncatedGoAwayPacket) {
@@ -9504,57 +7684,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x2C,
-    // 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,
     // connection_id
@@ -9606,18 +7735,12 @@
   };
   // clang-format on
 
-  unsigned char* p = packet;
-  size_t p_size = ABSL_ARRAYSIZE(packet);
-  if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
-  }
-
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
   quiche::test::CompareCharArraysWithHexError(
-      "constructed packet", data->data(), data->length(), AsChars(p), p_size);
+      "constructed packet", data->data(), data->length(), AsChars(packet),
+      ABSL_ARRAYSIZE(packet));
 }
 
 TEST_P(QuicFramerTest, BuildWindowUpdatePacket) {
@@ -9636,23 +7759,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x2C,
-    // 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,
     // connection_id
@@ -9695,9 +7801,6 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
     p_size = ABSL_ARRAYSIZE(packet_ietf);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
   }
 
   quiche::test::CompareCharArraysWithHexError(
@@ -9817,20 +7920,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x2C,
-    // 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,
     // connection_id
@@ -9867,9 +7956,6 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
     p_size = ABSL_ARRAYSIZE(packet_ietf);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
   }
 
   quiche::test::CompareCharArraysWithHexError(
@@ -9888,18 +7974,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x2C,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (ping frame)
-    0x07,
-  };
-
-  unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
     // connection_id
@@ -9927,8 +8001,6 @@
   unsigned char* p = packet;
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
   }
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
@@ -9936,8 +8008,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p),
-      framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
-                                                 : ABSL_ARRAYSIZE(packet));
+      ABSL_ARRAYSIZE(packet));
 }
 
 TEST_P(QuicFramerTest, BuildHandshakeDonePacket) {
@@ -10022,9 +8093,6 @@
 }
 
 TEST_P(QuicFramerTest, BuildMessagePacket) {
-  if (!VersionSupportsMessageFrames(framer_.transport_version())) {
-    return;
-  }
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
   QuicPacketHeader header;
   header.destination_connection_id = FramerTestConnectionId();
@@ -10037,7 +8105,7 @@
   QuicFrames frames = {QuicFrame(&frame), QuicFrame(&frame2)};
 
   // clang-format off
-  unsigned char packet46[] = {
+  unsigned char packet[] = {
     // type (short header, 4 byte packet number)
     0x43,
     // connection_id
@@ -10078,7 +8146,7 @@
   };
   // clang-format on
 
-  unsigned char* p = packet46;
+  unsigned char* p = packet;
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
   }
@@ -10088,7 +8156,7 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p),
-      ABSL_ARRAYSIZE(packet46));
+      ABSL_ARRAYSIZE(packet));
 }
 
 // Test that the MTU discovery packet is serialized correctly as a PING packet.
@@ -10104,18 +8172,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x2C,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (ping frame)
-    0x07,
-  };
-
-  unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
     // connection_id
@@ -10146,14 +8202,11 @@
   unsigned char* p = packet;
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
   }
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p),
-      framer_.version().HasIetfInvariantHeader() ? ABSL_ARRAYSIZE(packet46)
-                                                 : ABSL_ARRAYSIZE(packet));
+      ABSL_ARRAYSIZE(packet));
 }
 
 TEST_P(QuicFramerTest, BuildPublicResetPacket) {
@@ -10181,10 +8234,6 @@
   };
   // clang-format on
 
-  if (framer_.version().HasIetfInvariantHeader()) {
-    return;
-  }
-
   std::unique_ptr<QuicEncryptedPacket> data(
       framer_.BuildPublicResetPacket(reset_packet));
   ASSERT_TRUE(data != nullptr);
@@ -10229,10 +8278,6 @@
   };
   // clang-format on
 
-  if (framer_.version().HasIetfInvariantHeader()) {
-    return;
-  }
-
   std::unique_ptr<QuicEncryptedPacket> data(
       framer_.BuildPublicResetPacket(reset_packet));
   ASSERT_TRUE(data != nullptr);
@@ -10301,10 +8346,6 @@
   };
   // clang-format on
 
-  if (framer_.version().HasIetfInvariantHeader()) {
-    return;
-  }
-
   std::unique_ptr<QuicEncryptedPacket> data(
       framer_.BuildPublicResetPacket(reset_packet));
   ASSERT_TRUE(data != nullptr);
@@ -10414,21 +8455,6 @@
   QuicPacketNumber packet_number = kPacketNumber;
   // clang-format off
   unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x28,
-    // 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,
     // connection_id
@@ -10465,8 +8491,6 @@
   if (framer_.version().HasHeaderProtection()) {
     p = packet50;
     p_size = ABSL_ARRAYSIZE(packet50);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
   }
 
   std::unique_ptr<QuicPacket> raw(new QuicPacket(
@@ -10508,23 +8532,6 @@
   QuicPacketNumber packet_number = kPacketNumber;
   // clang-format off
   unsigned char packet[] = {
-    // public flags (version, 8 byte connection_id)
-    0x29,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // version tag
-    'Q', '.', '1', '0',
-    // 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,
     // version tag
@@ -10572,9 +8579,6 @@
   if (framer_.version().HasHeaderProtection()) {
     p = packet50;
     p_size = ABSL_ARRAYSIZE(packet50);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
   }
 
   std::unique_ptr<QuicPacket> raw(new QuicPacket(
@@ -10774,43 +8778,6 @@
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x28,
-    // 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,
     // connection_id
@@ -10901,9 +8868,6 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
     p_size = ABSL_ARRAYSIZE(packet_ietf);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
   }
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
@@ -13390,26 +11354,6 @@
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x2C,
-    // 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,
     // connection_id
@@ -13455,8 +11399,6 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
     p_size = ABSL_ARRAYSIZE(packet_ietf);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -13468,26 +11410,6 @@
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x2C,
-    // 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,
     // connection_id
@@ -13533,9 +11455,6 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
     p_size = ABSL_ARRAYSIZE(packet_ietf);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -13548,36 +11467,6 @@
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
   // clang-format off
   unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x2C,
-    // 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,
     // connection_id
@@ -13641,9 +11530,6 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet_ietf;
     p_size = ABSL_ARRAYSIZE(packet_ietf);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_size = ABSL_ARRAYSIZE(packet46);
   }
 
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
@@ -14117,20 +12003,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-    // public flags (version included, 8-byte connection ID,
-    // 4-byte packet number)
-    0x28,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x00,
-    // padding frames
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  };
-  unsigned char packet46[] = {
     // public flags (long header with packet type HANDSHAKE and
     // 4-byte packet number)
     0xE3,
@@ -14179,9 +12051,6 @@
     ReviseFirstByteByVersion(packet49);
     p = packet49;
     p_length = ABSL_ARRAYSIZE(packet49);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_length = ABSL_ARRAYSIZE(packet46);
   }
   // First attempt decryption without the handshake crypter.
   EXPECT_FALSE(
@@ -14220,20 +12089,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-    // public flags (version included, 8-byte connection ID,
-    // 4-byte packet number)
-    0x28,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x00,
-    // padding frames
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  };
-  unsigned char packet46[] = {
     // public flags (long header with packet type HANDSHAKE and
     // 4-byte packet number)
     0xE3,
@@ -14282,9 +12137,6 @@
     ReviseFirstByteByVersion(packet49);
     p = packet49;
     p_length = ABSL_ARRAYSIZE(packet49);
-  } else if (framer_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    p_length = ABSL_ARRAYSIZE(packet46);
   }
 
   EXPECT_FALSE(
@@ -14813,9 +12665,6 @@
 }
 
 TEST_P(QuicFramerTest, ClientReceivesWrongVersion) {
-  if (!framer_.version().HasIetfInvariantHeader()) {
-    return;
-  }
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
 
   // clang-format off
@@ -14905,9 +12754,6 @@
 }
 
 TEST_P(QuicFramerTest, MultiplePacketNumberSpaces) {
-  if (!framer_.version().HasIetfInvariantHeader()) {
-    return;
-  }
   framer_.EnableMultiplePacketNumberSpacesSupport();
 
   // clang-format off
@@ -15019,7 +12865,7 @@
   }
 
   // clang-format off
-  PacketFragments packet46 = {
+  PacketFragments packet = {
     // public flags (IETF Retry packet, 0-length original destination CID)
     {"Unable to read first byte.",
      {0xf0}},
@@ -15033,16 +12879,15 @@
   // clang-format on
 
   std::unique_ptr<QuicEncryptedPacket> encrypted(
-      AssemblePacketFromFragments(packet46));
+      AssemblePacketFromFragments(packet));
 
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
   EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_PACKET_HEADER));
-  CheckFramingBoundaries(packet46, QUIC_INVALID_PACKET_HEADER);
+  CheckFramingBoundaries(packet, QUIC_INVALID_PACKET_HEADER);
 }
 
 TEST_P(QuicFramerTest, RetryPacketRejectedWithMultiplePacketNumberSpaces) {
-  if (!framer_.version().HasIetfInvariantHeader() ||
-      framer_.version().SupportsRetry()) {
+  if (framer_.version().SupportsRetry()) {
     return;
   }
   framer_.EnableMultiplePacketNumberSpacesSupport();
@@ -15367,10 +13212,6 @@
 }
 
 TEST_P(QuicFramerTest, ClientConnectionIdFromLongHeaderToClient) {
-  if (!framer_.version().HasIetfInvariantHeader()) {
-    // This test requires an IETF long header.
-    return;
-  }
   SetDecrypterLevel(ENCRYPTION_HANDSHAKE);
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
   // clang-format off
@@ -15436,10 +13277,6 @@
 }
 
 TEST_P(QuicFramerTest, ClientConnectionIdFromLongHeaderToServer) {
-  if (!framer_.version().HasIetfInvariantHeader()) {
-    // This test requires an IETF long header.
-    return;
-  }
   SetDecrypterLevel(ENCRYPTION_HANDSHAKE);
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_SERVER);
   // clang-format off
@@ -15509,10 +13346,6 @@
 }
 
 TEST_P(QuicFramerTest, ProcessAndValidateIetfConnectionIdLengthClient) {
-  if (!framer_.version().HasIetfInvariantHeader()) {
-    // This test requires an IETF long header.
-    return;
-  }
   char connection_id_lengths = 0x05;
   QuicDataReader reader(&connection_id_lengths, 1);
 
@@ -15547,10 +13380,6 @@
 }
 
 TEST_P(QuicFramerTest, ProcessAndValidateIetfConnectionIdLengthServer) {
-  if (!framer_.version().HasIetfInvariantHeader()) {
-    // This test requires an IETF long header.
-    return;
-  }
   char connection_id_lengths = 0x50;
   QuicDataReader reader(&connection_id_lengths, 1);
 
@@ -16349,12 +14178,7 @@
     0x00, 0x00, 0x00, 0x00
   };
   MockConnectionIdGenerator generator;
-  if (version_.HasIetfInvariantHeader()) {
     EXPECT_CALL(generator, ConnectionIdLength(0x28)).WillOnce(Return(9));
-  } else {
-    packet[0] = 0x0a;
-    EXPECT_CALL(generator, ConnectionIdLength(_)).Times(0);
-  }
   unsigned char* p = packet;
   size_t p_size = ABSL_ARRAYSIZE(packet);
 
@@ -16384,13 +14208,8 @@
           &use_length_prefix, &version_label, &parsed_version,
           &destination_connection_id, &source_connection_id, &retry_token,
           &detailed_error, generator));
-  if (version_.HasIetfInvariantHeader()) {
-    EXPECT_EQ(format, IETF_QUIC_SHORT_HEADER_PACKET);
-    EXPECT_EQ(destination_connection_id.length(), 9);
-  } else {
-    EXPECT_EQ(format, GOOGLE_QUIC_PACKET);
-    EXPECT_EQ(destination_connection_id.length(), 8);
-  }
+  EXPECT_EQ(format, IETF_QUIC_SHORT_HEADER_PACKET);
+  EXPECT_EQ(destination_connection_id.length(), 9);
   EXPECT_EQ(long_packet_type, INVALID_PACKET_TYPE);
   EXPECT_FALSE(version_flag);
   EXPECT_FALSE(use_length_prefix);
diff --git a/quiche/quic/core/quic_packet_creator.cc b/quiche/quic/core/quic_packet_creator.cc
index c04a418..63c07b6 100644
--- a/quiche/quic/core/quic_packet_creator.cc
+++ b/quiche/quic/core/quic_packet_creator.cc
@@ -115,7 +115,6 @@
       debug_delegate_(nullptr),
       framer_(framer),
       random_(random),
-      send_version_in_packet_(framer->perspective() == Perspective::IS_CLIENT),
       have_diversification_nonce_(false),
       max_packet_length_(0),
       server_connection_id_included_(CONNECTION_ID_PRESENT),
@@ -215,19 +214,6 @@
   max_plaintext_size_ = framer_->GetMaxPlaintextSize(length);
 }
 
-// Stops serializing version of the protocol in packets sent after this call.
-// A packet that is already open might send kQuicVersionSize bytes less than the
-// maximum packet size if we stop sending version before it is serialized.
-void QuicPacketCreator::StopSendingVersion() {
-  QUICHE_DCHECK(send_version_in_packet_) << ENDPOINT;
-  QUICHE_DCHECK(!version().HasIetfInvariantHeader()) << ENDPOINT;
-  send_version_in_packet_ = false;
-  if (packet_size_ > 0) {
-    QUICHE_DCHECK_LT(kQuicVersionSize, packet_size_) << ENDPOINT;
-    packet_size_ -= kQuicVersionSize;
-  }
-}
-
 void QuicPacketCreator::SetDiversificationNonce(
     const DiversificationNonce& nonce) {
   QUICHE_DCHECK(!have_diversification_nonce_) << ENDPOINT;
@@ -366,8 +352,8 @@
 }
 
 bool QuicPacketCreator::HasRoomForMessageFrame(QuicByteCount length) {
-  const size_t message_frame_size = QuicFramer::GetMessageFrameSize(
-      framer_->transport_version(), /*last_frame_in_packet=*/true, length);
+  const size_t message_frame_size =
+      QuicFramer::GetMessageFrameSize(/*last_frame_in_packet=*/true, length);
   if (static_cast<QuicByteCount>(message_frame_size) >
       max_datagram_frame_size_) {
     return false;
@@ -609,7 +595,7 @@
 
   QuicDataWriter writer(kMaxOutgoingPacketSize, encrypted_buffer);
   size_t length_field_offset = 0;
-  if (!framer_->AppendPacketHeader(header, &writer, &length_field_offset)) {
+  if (!framer_->AppendIetfPacketHeader(header, &writer, &length_field_offset)) {
     QUIC_BUG(quic_bug_10752_9) << ENDPOINT << "AppendPacketHeader failed";
     return;
   }
@@ -1968,10 +1954,7 @@
 }
 
 bool QuicPacketCreator::IncludeVersionInHeader() const {
-  if (version().HasIetfInvariantHeader()) {
-    return packet_.encryption_level < ENCRYPTION_FORWARD_SECURE;
-  }
-  return send_version_in_packet_;
+  return packet_.encryption_level < ENCRYPTION_FORWARD_SECURE;
 }
 
 void QuicPacketCreator::AddPendingPadding(QuicByteCount size) {
@@ -2016,9 +1999,6 @@
 }
 
 QuicPacketLength QuicPacketCreator::GetCurrentLargestMessagePayload() const {
-  if (!VersionSupportsMessageFrames(framer_->transport_version())) {
-    return 0;
-  }
   const size_t packet_header_size = GetPacketHeaderSize(
       framer_->transport_version(), GetDestinationConnectionIdLength(),
       GetSourceConnectionIdLength(), IncludeVersionInHeader(),
@@ -2040,9 +2020,6 @@
 }
 
 QuicPacketLength QuicPacketCreator::GetGuaranteedLargestMessagePayload() const {
-  if (!VersionSupportsMessageFrames(framer_->transport_version())) {
-    return 0;
-  }
   // QUIC Crypto server packets may include a diversification nonce.
   const bool may_include_nonce =
       framer_->version().handshake_protocol == PROTOCOL_QUIC_CRYPTO &&
@@ -2097,8 +2074,7 @@
 }
 
 bool QuicPacketCreator::HasIetfLongHeader() const {
-  return version().HasIetfInvariantHeader() &&
-         packet_.encryption_level < ENCRYPTION_FORWARD_SECURE;
+  return packet_.encryption_level < ENCRYPTION_FORWARD_SECURE;
 }
 
 // static
diff --git a/quiche/quic/core/quic_packet_creator.h b/quiche/quic/core/quic_packet_creator.h
index 785efb1..8396b1c 100644
--- a/quiche/quic/core/quic_packet_creator.h
+++ b/quiche/quic/core/quic_packet_creator.h
@@ -119,9 +119,6 @@
 
   ~QuicPacketCreator();
 
-  // Makes the framer not serialize the protocol version in sent packets.
-  void StopSendingVersion();
-
   // SetDiversificationNonce sets the nonce that will be sent in each public
   // header of packets encrypted at the initial encryption level. Should only
   // be called by servers.
@@ -622,10 +619,6 @@
   QuicFramer* framer_;
   QuicRandom* random_;
 
-  // Controls whether version should be included while serializing the packet.
-  // send_version_in_packet_ should never be read directly, use
-  // IncludeVersionInHeader() instead.
-  bool send_version_in_packet_;
   // If true, then |diversification_nonce_| will be included in the header of
   // all packets created at the initial encryption level.
   bool have_diversification_nonce_;
diff --git a/quiche/quic/core/quic_packet_creator_test.cc b/quiche/quic/core/quic_packet_creator_test.cc
index b2fec7b..6ff1bc1 100644
--- a/quiche/quic/core/quic_packet_creator_test.cc
+++ b/quiche/quic/core/quic_packet_creator_test.cc
@@ -113,13 +113,7 @@
         frame);
   }
 
-  void StopSendingVersion() {
-    if (version_.HasIetfInvariantHeader()) {
-      set_encryption_level(ENCRYPTION_FORWARD_SECURE);
-      return;
-    }
-    QuicPacketCreator::StopSendingVersion();
-  }
+  void StopSendingVersion() { set_encryption_level(ENCRYPTION_FORWARD_SECURE); }
 
   SimpleDataProducer* producer_;
   ParsedQuicVersion version_;
@@ -639,21 +633,6 @@
 
   // clang-format off
   unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x2C,
-    // connection_id
-    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
-    // packet number
-    0x12, 0x34, 0x56, 0x78,
-
-    // frame type (ping frame)
-    0x07,
-    // frame type (padding frame)
-    0x00,
-    0x00, 0x00, 0x00, 0x00
-  };
-
-  unsigned char packet46[] = {
     // type (short header, 4 byte packet number)
     0x43,
     // connection_id
@@ -689,9 +668,6 @@
   if (creator_.version().HasIetfQuicFrames()) {
     p = packet99;
     packet_size = ABSL_ARRAYSIZE(packet99);
-  } else if (creator_.version().HasIetfInvariantHeader()) {
-    p = packet46;
-    packet_size = ABSL_ARRAYSIZE(packet46);
   }
 
   std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
@@ -1162,8 +1138,7 @@
 }
 
 TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthLeastAwaiting) {
-  if (creator_.version().HasIetfInvariantHeader() &&
-      !GetParam().version.SendsVariableLengthPacketNumberInLongHeader()) {
+  if (!GetParam().version.SendsVariableLengthPacketNumberInLongHeader()) {
     EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
               QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
     creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
@@ -1200,8 +1175,7 @@
 
 TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthCwnd) {
   QuicPacketCreatorPeer::SetPacketNumber(&creator_, 1);
-  if (creator_.version().HasIetfInvariantHeader() &&
-      !GetParam().version.SendsVariableLengthPacketNumberInLongHeader()) {
+  if (!GetParam().version.SendsVariableLengthPacketNumberInLongHeader()) {
     EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
               QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
     creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
@@ -1234,8 +1208,7 @@
 
 TEST_P(QuicPacketCreatorTest, SkipNPacketNumbers) {
   QuicPacketCreatorPeer::SetPacketNumber(&creator_, 1);
-  if (creator_.version().HasIetfInvariantHeader() &&
-      !GetParam().version.SendsVariableLengthPacketNumberInLongHeader()) {
+  if (!GetParam().version.SendsVariableLengthPacketNumberInLongHeader()) {
     EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
               QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
     creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
@@ -1741,9 +1714,6 @@
 }
 
 TEST_P(QuicPacketCreatorTest, AddMessageFrame) {
-  if (!VersionSupportsMessageFrames(client_framer_.transport_version())) {
-    return;
-  }
   if (client_framer_.version().UsesTls()) {
     creator_.SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
   }
@@ -1794,9 +1764,6 @@
 }
 
 TEST_P(QuicPacketCreatorTest, MessageFrameConsumption) {
-  if (!VersionSupportsMessageFrames(client_framer_.transport_version())) {
-    return;
-  }
   if (client_framer_.version().UsesTls()) {
     creator_.SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
   }
@@ -1839,9 +1806,6 @@
 
 TEST_P(QuicPacketCreatorTest, GetGuaranteedLargestMessagePayload) {
   ParsedQuicVersion version = GetParam().version;
-  if (!version.SupportsMessageFrames()) {
-    return;
-  }
   if (version.UsesTls()) {
     creator_.SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
   }
@@ -1890,9 +1854,6 @@
 
 TEST_P(QuicPacketCreatorTest, GetCurrentLargestMessagePayload) {
   ParsedQuicVersion version = GetParam().version;
-  if (!version.SupportsMessageFrames()) {
-    return;
-  }
   if (version.UsesTls()) {
     creator_.SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
   }
@@ -2358,19 +2319,17 @@
   EXPECT_EQ(previous_max_packet_length, creator_.max_packet_length());
 
   // Same for message frame.
-  if (VersionSupportsMessageFrames(client_framer_.transport_version())) {
-    creator_.SetSoftMaxPacketLength(overhead);
-    if (client_framer_.version().UsesTls()) {
-      creator_.SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
-    }
-    // Verify GetCurrentLargestMessagePayload is based on the actual
-    // max_packet_length.
-    EXPECT_LT(1u, creator_.GetCurrentLargestMessagePayload());
-    EXPECT_EQ(overhead, creator_.max_packet_length());
-    ASSERT_TRUE(creator_.HasRoomForMessageFrame(
-        creator_.GetCurrentLargestMessagePayload()));
-    EXPECT_EQ(previous_max_packet_length, creator_.max_packet_length());
+  creator_.SetSoftMaxPacketLength(overhead);
+  if (client_framer_.version().UsesTls()) {
+    creator_.SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
   }
+  // Verify GetCurrentLargestMessagePayload is based on the actual
+  // max_packet_length.
+  EXPECT_LT(1u, creator_.GetCurrentLargestMessagePayload());
+  EXPECT_EQ(overhead, creator_.max_packet_length());
+  ASSERT_TRUE(creator_.HasRoomForMessageFrame(
+      creator_.GetCurrentLargestMessagePayload()));
+  EXPECT_EQ(previous_max_packet_length, creator_.max_packet_length());
 
   // Verify creator can consume crypto data because max_packet_length_ gets
   // restored.
@@ -3438,11 +3397,7 @@
 
   for (size_t i = 1; i < 10; i++) {
     creator_.SetServerConnectionIdLength(i);
-    if (framer_.version().HasIetfInvariantHeader()) {
-      EXPECT_EQ(0, creator_.GetDestinationConnectionIdLength());
-    } else {
-      EXPECT_EQ(8, creator_.GetDestinationConnectionIdLength());
-    }
+    EXPECT_EQ(0, creator_.GetDestinationConnectionIdLength());
   }
 }
 
@@ -3729,27 +3684,6 @@
   CheckPacketHasSingleStreamFrame(4);
 }
 
-TEST_F(QuicPacketCreatorMultiplePacketsTest, DontCrashOnInvalidStopWaiting) {
-  if (VersionSupportsMessageFrames(framer_.transport_version())) {
-    return;
-  }
-  // Test added to ensure the creator does not crash when an invalid frame is
-  // added.  Because this is an indication of internal programming errors,
-  // DFATALs are expected.
-  // A 1 byte packet number length can't encode a gap of 1000.
-  QuicPacketCreatorPeer::SetPacketNumber(&creator_, 1000);
-
-  delegate_.SetCanNotWrite();
-  delegate_.SetCanWriteAnything();
-
-  // This will not serialize any packets, because of the invalid frame.
-  EXPECT_CALL(delegate_,
-              OnUnrecoverableError(QUIC_FAILED_TO_SERIALIZE_PACKET, _));
-  EXPECT_QUIC_BUG(creator_.Flush(),
-                  "packet_number_length 1 is too small "
-                  "for least_unacked_delta: 1001");
-}
-
 // Regression test for b/31486443.
 TEST_F(QuicPacketCreatorMultiplePacketsTest,
        ConnectionCloseFrameLargerThanPacketSize) {
@@ -3926,9 +3860,6 @@
 }
 
 TEST_F(QuicPacketCreatorMultiplePacketsTest, AddMessageFrame) {
-  if (!VersionSupportsMessageFrames(framer_.transport_version())) {
-    return;
-  }
   if (framer_.version().UsesTls()) {
     creator_.SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
   }
diff --git a/quiche/quic/core/quic_packets.cc b/quiche/quic/core/quic_packets.cc
index 39e7eaf..2262877 100644
--- a/quiche/quic/core/quic_packets.cc
+++ b/quiche/quic/core/quic_packets.cc
@@ -106,38 +106,29 @@
     quiche::QuicheVariableLengthIntegerLength retry_token_length_length,
     QuicByteCount retry_token_length,
     quiche::QuicheVariableLengthIntegerLength length_length) {
-  if (VersionHasIetfInvariantHeader(version)) {
-    if (include_version) {
-      // Long header.
-      size_t size = kPacketHeaderTypeSize + kConnectionIdLengthSize +
-                    destination_connection_id_length +
-                    source_connection_id_length + packet_number_length +
-                    kQuicVersionSize;
-      if (include_diversification_nonce) {
-        size += kDiversificationNonceSize;
-      }
-      if (VersionHasLengthPrefixedConnectionIds(version)) {
-        size += kConnectionIdLengthSize;
-      }
-      QUICHE_DCHECK(
-          QuicVersionHasLongHeaderLengths(version) ||
-          retry_token_length_length + retry_token_length + length_length == 0);
-      if (QuicVersionHasLongHeaderLengths(version)) {
-        size += retry_token_length_length + retry_token_length + length_length;
-      }
-      return size;
+  if (include_version) {
+    // Long header.
+    size_t size = kPacketHeaderTypeSize + kConnectionIdLengthSize +
+                  destination_connection_id_length +
+                  source_connection_id_length + packet_number_length +
+                  kQuicVersionSize;
+    if (include_diversification_nonce) {
+      size += kDiversificationNonceSize;
     }
-    // Short header.
-    return kPacketHeaderTypeSize + destination_connection_id_length +
-           packet_number_length;
+    if (VersionHasLengthPrefixedConnectionIds(version)) {
+      size += kConnectionIdLengthSize;
+    }
+    QUICHE_DCHECK(
+        QuicVersionHasLongHeaderLengths(version) ||
+        retry_token_length_length + retry_token_length + length_length == 0);
+    if (QuicVersionHasLongHeaderLengths(version)) {
+      size += retry_token_length_length + retry_token_length + length_length;
+    }
+    return size;
   }
-  // Google QUIC versions <= 43 can only carry one connection ID.
-  QUICHE_DCHECK(destination_connection_id_length == 0 ||
-                source_connection_id_length == 0);
-  return kPublicFlagsSize + destination_connection_id_length +
-         source_connection_id_length +
-         (include_version ? kQuicVersionSize : 0) + packet_number_length +
-         (include_diversification_nonce ? kDiversificationNonceSize : 0);
+  // Short header.
+  return kPacketHeaderTypeSize + destination_connection_id_length +
+         packet_number_length;
 }
 
 size_t GetStartOfEncryptedData(QuicTransportVersion version,
diff --git a/quiche/quic/core/quic_received_packet_manager.h b/quiche/quic/core/quic_received_packet_manager.h
index ab298d4..0f80865 100644
--- a/quiche/quic/core/quic_received_packet_manager.h
+++ b/quiche/quic/core/quic_received_packet_manager.h
@@ -80,10 +80,6 @@
   // packets of the largest observed.
   virtual bool HasNewMissingPackets() const;
 
-  QuicPacketNumber peer_least_packet_awaiting_ack() const {
-    return peer_least_packet_awaiting_ack_;
-  }
-
   virtual bool ack_frame_updated() const;
 
   QuicPacketNumber GetLargestObserved() const;
diff --git a/quiche/quic/core/quic_time_wait_list_manager_test.cc b/quiche/quic/core/quic_time_wait_list_manager_test.cc
index 9567519..eef0b99 100644
--- a/quiche/quic/core/quic_time_wait_list_manager_test.cc
+++ b/quiche/quic/core/quic_time_wait_list_manager_test.cc
@@ -49,14 +49,6 @@
       : connection_id_(connection_id) {}
   ~FramerVisitorCapturingPublicReset() override = default;
 
-  void OnPublicResetPacket(const QuicPublicResetPacket& public_reset) override {
-    public_reset_packet_ = public_reset;
-  }
-
-  const QuicPublicResetPacket public_reset_packet() {
-    return public_reset_packet_;
-  }
-
   bool IsValidStatelessResetToken(
       const StatelessResetToken& token) const override {
     return token == QuicUtils::GenerateStatelessResetToken(connection_id_);
@@ -72,7 +64,6 @@
   }
 
  private:
-  QuicPublicResetPacket public_reset_packet_;
   QuicIetfStatelessResetPacket stateless_reset_packet_;
   QuicConnectionId connection_id_;
 };
@@ -144,7 +135,7 @@
 
   void AddConnectionId(QuicConnectionId connection_id,
                        QuicTimeWaitListManager::TimeWaitAction action) {
-    AddConnectionId(connection_id, QuicVersionMax(), action, nullptr);
+    AddConnectionId(connection_id, action, nullptr);
   }
 
   void AddStatelessConnectionId(QuicConnectionId connection_id) {
@@ -157,12 +148,12 @@
   }
 
   void AddConnectionId(
-      QuicConnectionId connection_id, ParsedQuicVersion version,
+      QuicConnectionId connection_id,
       QuicTimeWaitListManager::TimeWaitAction action,
       std::vector<std::unique_ptr<QuicEncryptedPacket>>* packets) {
     time_wait_list_manager_.AddConnectionIdToTimeWait(
-        action, TimeWaitConnectionInfo(version.HasIetfInvariantHeader(),
-                                       packets, {connection_id}));
+        action,
+        TimeWaitConnectionInfo(/*ietf_quic=*/true, packets, {connection_id}));
   }
 
   bool IsConnectionIdInTimeWait(QuicConnectionId connection_id) {
@@ -204,11 +195,6 @@
   QuicEncryptedPacket encrypted(std::get<0>(packet_buffer),
                                 std::get<1>(packet_buffer));
   framer.ProcessPacket(encrypted);
-  QuicPublicResetPacket packet = visitor.public_reset_packet();
-  bool public_reset_is_valid =
-      expected_connection_id == packet.connection_id &&
-      TestPeerIPAddress() == packet.client_address.host() &&
-      kTestPort == packet.client_address.port();
 
   QuicIetfStatelessResetPacket stateless_reset =
       visitor.stateless_reset_packet();
@@ -216,10 +202,8 @@
   StatelessResetToken expected_stateless_reset_token =
       QuicUtils::GenerateStatelessResetToken(expected_connection_id);
 
-  bool stateless_reset_is_valid =
-      stateless_reset.stateless_reset_token == expected_stateless_reset_token;
-
-  return public_reset_is_valid || stateless_reset_is_valid;
+  return stateless_reset.stateless_reset_token ==
+         expected_stateless_reset_token;
 }
 
 Matcher<const std::tuple<const char*, int>> PublicResetPacketEq(
@@ -319,7 +303,7 @@
   termination_packets.push_back(
       std::unique_ptr<QuicEncryptedPacket>(new QuicEncryptedPacket(
           new char[kConnectionCloseLength], kConnectionCloseLength, true)));
-  AddConnectionId(connection_id_, QuicVersionMax(),
+  AddConnectionId(connection_id_,
                   QuicTimeWaitListManager::SEND_CONNECTION_CLOSE_PACKETS,
                   &termination_packets);
   EXPECT_CALL(writer_, WritePacket(_, kConnectionCloseLength,
@@ -339,7 +323,7 @@
   termination_packets.push_back(
       std::unique_ptr<QuicEncryptedPacket>(new QuicEncryptedPacket(
           new char[kConnectionCloseLength], kConnectionCloseLength, true)));
-  AddConnectionId(connection_id_, QuicVersionMax(),
+  AddConnectionId(connection_id_,
                   QuicTimeWaitListManager::SEND_CONNECTION_CLOSE_PACKETS,
                   &termination_packets);
   EXPECT_CALL(writer_, WritePacket(_, kConnectionCloseLength,
@@ -536,7 +520,7 @@
   termination_packets.push_back(
       std::unique_ptr<QuicEncryptedPacket>(new QuicEncryptedPacket(
           new char[kConnectionCloseLength], kConnectionCloseLength, true)));
-  AddConnectionId(connection_id_, QuicVersionMax(),
+  AddConnectionId(connection_id_,
                   QuicTimeWaitListManager::SEND_TERMINATION_PACKETS,
                   &termination_packets);
   EXPECT_TRUE(IsConnectionIdInTimeWait(connection_id_));
diff --git a/quiche/quic/core/quic_utils_test.cc b/quiche/quic/core/quic_utils_test.cc
index 543c8ea..a391cc2 100644
--- a/quiche/quic/core/quic_utils_test.cc
+++ b/quiche/quic/core/quic_utils_test.cc
@@ -204,17 +204,17 @@
 }
 
 TEST_F(QuicUtilsTest, VariableLengthConnectionId) {
-  EXPECT_FALSE(VersionAllowsVariableLengthConnectionIds(QUIC_VERSION_43));
+  EXPECT_FALSE(VersionAllowsVariableLengthConnectionIds(QUIC_VERSION_46));
   EXPECT_TRUE(QuicUtils::IsConnectionIdValidForVersion(
-      QuicUtils::CreateZeroConnectionId(QUIC_VERSION_43), QUIC_VERSION_43));
+      QuicUtils::CreateZeroConnectionId(QUIC_VERSION_46), QUIC_VERSION_46));
   EXPECT_TRUE(QuicUtils::IsConnectionIdValidForVersion(
       QuicUtils::CreateZeroConnectionId(QUIC_VERSION_50), QUIC_VERSION_50));
-  EXPECT_NE(QuicUtils::CreateZeroConnectionId(QUIC_VERSION_43),
+  EXPECT_NE(QuicUtils::CreateZeroConnectionId(QUIC_VERSION_46),
             EmptyQuicConnectionId());
   EXPECT_EQ(QuicUtils::CreateZeroConnectionId(QUIC_VERSION_50),
             EmptyQuicConnectionId());
   EXPECT_FALSE(QuicUtils::IsConnectionIdValidForVersion(EmptyQuicConnectionId(),
-                                                        QUIC_VERSION_43));
+                                                        QUIC_VERSION_46));
 }
 
 TEST_F(QuicUtilsTest, StatelessResetToken) {
diff --git a/quiche/quic/core/quic_version_manager.cc b/quiche/quic/core/quic_version_manager.cc
index ec2b9ef..91404ed 100644
--- a/quiche/quic/core/quic_version_manager.cc
+++ b/quiche/quic/core/quic_version_manager.cc
@@ -36,7 +36,7 @@
 }
 
 void QuicVersionManager::MaybeRefilterSupportedVersions() {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync");
   if (enable_version_2_draft_08_ !=
           GetQuicReloadableFlag(quic_enable_version_2_draft_08) ||
@@ -47,9 +47,7 @@
       disable_version_q050_ !=
           GetQuicReloadableFlag(quic_disable_version_q050) ||
       disable_version_q046_ !=
-          GetQuicReloadableFlag(quic_disable_version_q046) ||
-      disable_version_q043_ !=
-          GetQuicReloadableFlag(quic_disable_version_q043)) {
+          GetQuicReloadableFlag(quic_disable_version_q046)) {
     enable_version_2_draft_08_ =
         GetQuicReloadableFlag(quic_enable_version_2_draft_08);
     disable_version_rfcv1_ = GetQuicReloadableFlag(quic_disable_version_rfcv1);
@@ -57,7 +55,6 @@
         GetQuicReloadableFlag(quic_disable_version_draft_29);
     disable_version_q050_ = GetQuicReloadableFlag(quic_disable_version_q050);
     disable_version_q046_ = GetQuicReloadableFlag(quic_disable_version_q046);
-    disable_version_q043_ = GetQuicReloadableFlag(quic_disable_version_q043);
 
     RefilterSupportedVersions();
   }
diff --git a/quiche/quic/core/quic_version_manager.h b/quiche/quic/core/quic_version_manager.h
index c664fc4..5beee79 100644
--- a/quiche/quic/core/quic_version_manager.h
+++ b/quiche/quic/core/quic_version_manager.h
@@ -65,8 +65,6 @@
   bool disable_version_q050_ = true;
   // quic_disable_version_q046 flag
   bool disable_version_q046_ = true;
-  // quic_disable_version_q043 flag
-  bool disable_version_q043_ = true;
 
   // The list of versions that may be supported.
   const ParsedQuicVersionVector allowed_supported_versions_;
diff --git a/quiche/quic/core/quic_version_manager_test.cc b/quiche/quic/core/quic_version_manager_test.cc
index 3c3a00e..d9ae2b6 100644
--- a/quiche/quic/core/quic_version_manager_test.cc
+++ b/quiche/quic/core/quic_version_manager_test.cc
@@ -18,7 +18,7 @@
 class QuicVersionManagerTest : public QuicTest {};
 
 TEST_F(QuicVersionManagerTest, QuicVersionManager) {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync");
   for (const ParsedQuicVersion& version : AllSupportedVersions()) {
     QuicEnableVersion(version);
@@ -31,15 +31,13 @@
   ParsedQuicVersionVector expected_parsed_versions;
   expected_parsed_versions.push_back(ParsedQuicVersion::Q050());
   expected_parsed_versions.push_back(ParsedQuicVersion::Q046());
-  expected_parsed_versions.push_back(ParsedQuicVersion::Q043());
 
   EXPECT_EQ(expected_parsed_versions, manager.GetSupportedVersions());
 
   EXPECT_EQ(FilterSupportedVersions(AllSupportedVersions()),
             manager.GetSupportedVersions());
   EXPECT_TRUE(manager.GetSupportedVersionsWithOnlyHttp3().empty());
-  EXPECT_THAT(manager.GetSupportedAlpns(),
-              ElementsAre("h3-Q050", "h3-Q046", "h3-Q043"));
+  EXPECT_THAT(manager.GetSupportedAlpns(), ElementsAre("h3-Q050", "h3-Q046"));
 
   QuicEnableVersion(ParsedQuicVersion::Draft29());
   expected_parsed_versions.insert(expected_parsed_versions.begin(),
@@ -51,7 +49,7 @@
   EXPECT_EQ(CurrentSupportedHttp3Versions(),
             manager.GetSupportedVersionsWithOnlyHttp3());
   EXPECT_THAT(manager.GetSupportedAlpns(),
-              ElementsAre("h3-29", "h3-Q050", "h3-Q046", "h3-Q043"));
+              ElementsAre("h3-29", "h3-Q050", "h3-Q046"));
 
   QuicEnableVersion(ParsedQuicVersion::RFCv1());
   expected_parsed_versions.insert(expected_parsed_versions.begin(),
@@ -63,7 +61,7 @@
   EXPECT_EQ(CurrentSupportedHttp3Versions(),
             manager.GetSupportedVersionsWithOnlyHttp3());
   EXPECT_THAT(manager.GetSupportedAlpns(),
-              ElementsAre("h3", "h3-29", "h3-Q050", "h3-Q046", "h3-Q043"));
+              ElementsAre("h3", "h3-29", "h3-Q050", "h3-Q046"));
 
   QuicEnableVersion(ParsedQuicVersion::V2Draft08());
   expected_parsed_versions.insert(expected_parsed_versions.begin(),
@@ -75,7 +73,7 @@
   EXPECT_EQ(CurrentSupportedHttp3Versions(),
             manager.GetSupportedVersionsWithOnlyHttp3());
   EXPECT_THAT(manager.GetSupportedAlpns(),
-              ElementsAre("h3", "h3-29", "h3-Q050", "h3-Q046", "h3-Q043"));
+              ElementsAre("h3", "h3-29", "h3-Q050", "h3-Q046"));
 }
 
 }  // namespace
diff --git a/quiche/quic/core/quic_versions.cc b/quiche/quic/core/quic_versions.cc
index 1f03b70..fd3f6af 100644
--- a/quiche/quic/core/quic_versions.cc
+++ b/quiche/quic/core/quic_versions.cc
@@ -36,7 +36,7 @@
 }
 
 void SetVersionFlag(const ParsedQuicVersion& version, bool should_enable) {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync");
   const bool enable = should_enable;
   const bool disable = !should_enable;
@@ -50,8 +50,6 @@
     SetQuicReloadableFlag(quic_disable_version_q050, disable);
   } else if (version == ParsedQuicVersion::Q046()) {
     SetQuicReloadableFlag(quic_disable_version_q046, disable);
-  } else if (version == ParsedQuicVersion::Q043()) {
-    SetQuicReloadableFlag(quic_disable_version_q043, disable);
   } else {
     QUIC_BUG(quic_bug_10589_1)
         << "Cannot " << (enable ? "en" : "dis") << "able version " << version;
@@ -133,16 +131,6 @@
   return VersionSupportsGoogleAltSvcFormat(transport_version);
 }
 
-bool ParsedQuicVersion::HasIetfInvariantHeader() const {
-  QUICHE_DCHECK(IsKnown());
-  return VersionHasIetfInvariantHeader(transport_version);
-}
-
-bool ParsedQuicVersion::SupportsMessageFrames() const {
-  QUICHE_DCHECK(IsKnown());
-  return VersionSupportsMessageFrames(transport_version);
-}
-
 bool ParsedQuicVersion::UsesHttp3() const {
   QUICHE_DCHECK(IsKnown());
   return VersionUsesHttp3(transport_version);
@@ -223,7 +211,7 @@
 }
 
 QuicVersionLabel CreateQuicVersionLabel(ParsedQuicVersion parsed_version) {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync");
   if (parsed_version == ParsedQuicVersion::V2Draft08()) {
     return MakeVersionLabel(0x6b, 0x33, 0x43, 0xcf);
@@ -235,8 +223,6 @@
     return MakeVersionLabel('Q', '0', '5', '0');
   } else if (parsed_version == ParsedQuicVersion::Q046()) {
     return MakeVersionLabel('Q', '0', '4', '6');
-  } else if (parsed_version == ParsedQuicVersion::Q043()) {
-    return MakeVersionLabel('Q', '0', '4', '3');
   } else if (parsed_version == ParsedQuicVersion::ReservedForNegotiation()) {
     return CreateRandomVersionLabelForNegotiation();
   }
@@ -424,7 +410,7 @@
 
 ParsedQuicVersionVector FilterSupportedVersions(
     ParsedQuicVersionVector versions) {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync");
   ParsedQuicVersionVector filtered_versions;
   filtered_versions.reserve(versions.size());
@@ -449,10 +435,6 @@
       if (!GetQuicReloadableFlag(quic_disable_version_q046)) {
         filtered_versions.push_back(version);
       }
-    } else if (version == ParsedQuicVersion::Q043()) {
-      if (!GetQuicReloadableFlag(quic_disable_version_q043)) {
-        filtered_versions.push_back(version);
-      }
     } else {
       QUIC_BUG(quic_bug_10589_7)
           << "QUIC version " << version << " has no flag protection";
@@ -514,7 +496,6 @@
 
 std::string QuicVersionToString(QuicTransportVersion transport_version) {
   switch (transport_version) {
-    RETURN_STRING_LITERAL(QUIC_VERSION_43);
     RETURN_STRING_LITERAL(QUIC_VERSION_46);
     RETURN_STRING_LITERAL(QUIC_VERSION_50);
     RETURN_STRING_LITERAL(QUIC_VERSION_IETF_DRAFT_29);
@@ -538,7 +519,7 @@
 }
 
 std::string ParsedQuicVersionToString(ParsedQuicVersion version) {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync");
   if (version == UnsupportedQuicVersion()) {
     return "0";
@@ -604,8 +585,8 @@
   // and Google QUIC 49 and later use the new length prefixed encoding.
   // Similarly, only IETF drafts 11 to 21 used this encoding.
 
-  // Check Q044, Q045, Q046, Q047 and Q048.
-  for (uint8_t c = '4'; c <= '8'; ++c) {
+  // Check Q043, Q044, Q045, Q046, Q047 and Q048.
+  for (uint8_t c = '3'; c <= '8'; ++c) {
     if (version_label == MakeVersionLabel('Q', '0', '4', c)) {
       return true;
     }
diff --git a/quiche/quic/core/quic_versions.h b/quiche/quic/core/quic_versions.h
index a8cfab3..8129d9a 100644
--- a/quiche/quic/core/quic_versions.h
+++ b/quiche/quic/core/quic_versions.h
@@ -106,8 +106,7 @@
   //            or v41 are present in subsequent versions.
   // Version 42 allowed receiving overlapping stream data.
 
-  QUIC_VERSION_43 = 43,  // PRIORITY frames are sent by client and accepted by
-                         // server.
+  // Version 43 PRIORITY frames are sent by client and accepted by server.
   // Version 44 used IETF header format from draft-ietf-quic-invariants-05.
 
   // Version 45 added MESSAGE frame.
@@ -166,8 +165,8 @@
 }
 
 // Returns whether this combination of handshake protocol and transport
-// version is allowed. For example, {PROTOCOL_TLS1_3, QUIC_VERSION_43} is NOT
-// allowed as TLS requires crypto frames which v43 does not support. Note that
+// version is allowed. For example, {PROTOCOL_TLS1_3, QUIC_VERSION_46} is NOT
+// allowed as TLS requires crypto frames which v46 does not support. Note that
 // UnsupportedQuicVersion is a valid version.
 QUIC_EXPORT_PRIVATE constexpr bool ParsedQuicVersionIsValid(
     HandshakeProtocol handshake_protocol,
@@ -179,7 +178,6 @@
       QUIC_VERSION_IETF_DRAFT_29,
       QUIC_VERSION_50,
       QUIC_VERSION_46,
-      QUIC_VERSION_43,
       QUIC_VERSION_RESERVED_FOR_NEGOTIATION,
       QUIC_VERSION_UNSUPPORTED,
   };
@@ -270,10 +268,6 @@
     return ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_46);
   }
 
-  static constexpr ParsedQuicVersion Q043() {
-    return ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_43);
-  }
-
   static constexpr ParsedQuicVersion Unsupported() {
     return ParsedQuicVersion(PROTOCOL_UNSUPPORTED, QUIC_VERSION_UNSUPPORTED);
   }
@@ -333,12 +327,6 @@
   // advertisement format.
   bool SupportsGoogleAltSvcFormat() const;
 
-  // Returns true if |transport_version| uses IETF invariant headers.
-  bool HasIetfInvariantHeader() const;
-
-  // Returns true if |transport_version| supports MESSAGE frames.
-  bool SupportsMessageFrames() const;
-
   // If true, HTTP/3 instead of gQUIC will be used at the HTTP layer.
   // Notable changes are:
   // * Headers stream no longer exists.
@@ -410,11 +398,11 @@
   return {PROTOCOL_TLS1_3, PROTOCOL_QUIC_CRYPTO};
 }
 
-constexpr std::array<ParsedQuicVersion, 6> SupportedVersions() {
+constexpr std::array<ParsedQuicVersion, 5> SupportedVersions() {
   return {
       ParsedQuicVersion::V2Draft08(), ParsedQuicVersion::RFCv1(),
       ParsedQuicVersion::Draft29(),   ParsedQuicVersion::Q050(),
-      ParsedQuicVersion::Q046(),      ParsedQuicVersion::Q043(),
+      ParsedQuicVersion::Q046(),
   };
 }
 
@@ -563,19 +551,6 @@
                                          std::numeric_limits<size_t>::max());
 }
 
-// Returns true if |transport_version| uses IETF invariant headers.
-QUIC_EXPORT_PRIVATE constexpr bool VersionHasIetfInvariantHeader(
-    QuicTransportVersion transport_version) {
-  return transport_version > QUIC_VERSION_43;
-}
-
-// Returns true if |transport_version| supports MESSAGE frames.
-QUIC_EXPORT_PRIVATE constexpr bool VersionSupportsMessageFrames(
-    QuicTransportVersion transport_version) {
-  // MESSAGE frames were added in version 45.
-  return transport_version > QUIC_VERSION_43;
-}
-
 // If true, HTTP/3 instead of gQUIC will be used at the HTTP layer.
 // Notable changes are:
 // * Headers stream no longer exists.
diff --git a/quiche/quic/core/quic_versions_test.cc b/quiche/quic/core/quic_versions_test.cc
index 745b58a..49335e3 100644
--- a/quiche/quic/core/quic_versions_test.cc
+++ b/quiche/quic/core/quic_versions_test.cc
@@ -38,7 +38,7 @@
   EXPECT_TRUE(ParsedQuicVersionIsValid(reserved.handshake_protocol,
                                        reserved.transport_version));
   // Check that invalid combinations are not valid.
-  EXPECT_FALSE(ParsedQuicVersionIsValid(PROTOCOL_TLS1_3, QUIC_VERSION_43));
+  EXPECT_FALSE(ParsedQuicVersionIsValid(PROTOCOL_TLS1_3, QUIC_VERSION_46));
   EXPECT_FALSE(ParsedQuicVersionIsValid(PROTOCOL_QUIC_CRYPTO,
                                         QUIC_VERSION_IETF_DRAFT_29));
   // Check that deprecated versions are not valid.
@@ -51,31 +51,29 @@
 }
 
 TEST(QuicVersionsTest, Features) {
-  ParsedQuicVersion parsed_version_q043 = ParsedQuicVersion::Q043();
+  ParsedQuicVersion parsed_version_q046 = ParsedQuicVersion::Q046();
   ParsedQuicVersion parsed_version_draft_29 = ParsedQuicVersion::Draft29();
 
-  EXPECT_TRUE(parsed_version_q043.IsKnown());
-  EXPECT_FALSE(parsed_version_q043.KnowsWhichDecrypterToUse());
-  EXPECT_FALSE(parsed_version_q043.UsesInitialObfuscators());
-  EXPECT_FALSE(parsed_version_q043.AllowsLowFlowControlLimits());
-  EXPECT_FALSE(parsed_version_q043.HasHeaderProtection());
-  EXPECT_FALSE(parsed_version_q043.SupportsRetry());
+  EXPECT_TRUE(parsed_version_q046.IsKnown());
+  EXPECT_FALSE(parsed_version_q046.KnowsWhichDecrypterToUse());
+  EXPECT_FALSE(parsed_version_q046.UsesInitialObfuscators());
+  EXPECT_FALSE(parsed_version_q046.AllowsLowFlowControlLimits());
+  EXPECT_FALSE(parsed_version_q046.HasHeaderProtection());
+  EXPECT_FALSE(parsed_version_q046.SupportsRetry());
   EXPECT_FALSE(
-      parsed_version_q043.SendsVariableLengthPacketNumberInLongHeader());
-  EXPECT_FALSE(parsed_version_q043.AllowsVariableLengthConnectionIds());
-  EXPECT_FALSE(parsed_version_q043.SupportsClientConnectionIds());
-  EXPECT_FALSE(parsed_version_q043.HasLengthPrefixedConnectionIds());
-  EXPECT_FALSE(parsed_version_q043.SupportsAntiAmplificationLimit());
-  EXPECT_FALSE(parsed_version_q043.CanSendCoalescedPackets());
-  EXPECT_TRUE(parsed_version_q043.SupportsGoogleAltSvcFormat());
-  EXPECT_FALSE(parsed_version_q043.HasIetfInvariantHeader());
-  EXPECT_FALSE(parsed_version_q043.SupportsMessageFrames());
-  EXPECT_FALSE(parsed_version_q043.UsesHttp3());
-  EXPECT_FALSE(parsed_version_q043.HasLongHeaderLengths());
-  EXPECT_FALSE(parsed_version_q043.UsesCryptoFrames());
-  EXPECT_FALSE(parsed_version_q043.HasIetfQuicFrames());
-  EXPECT_FALSE(parsed_version_q043.UsesTls());
-  EXPECT_TRUE(parsed_version_q043.UsesQuicCrypto());
+      parsed_version_q046.SendsVariableLengthPacketNumberInLongHeader());
+  EXPECT_FALSE(parsed_version_q046.AllowsVariableLengthConnectionIds());
+  EXPECT_FALSE(parsed_version_q046.SupportsClientConnectionIds());
+  EXPECT_FALSE(parsed_version_q046.HasLengthPrefixedConnectionIds());
+  EXPECT_FALSE(parsed_version_q046.SupportsAntiAmplificationLimit());
+  EXPECT_FALSE(parsed_version_q046.CanSendCoalescedPackets());
+  EXPECT_TRUE(parsed_version_q046.SupportsGoogleAltSvcFormat());
+  EXPECT_FALSE(parsed_version_q046.UsesHttp3());
+  EXPECT_FALSE(parsed_version_q046.HasLongHeaderLengths());
+  EXPECT_FALSE(parsed_version_q046.UsesCryptoFrames());
+  EXPECT_FALSE(parsed_version_q046.HasIetfQuicFrames());
+  EXPECT_FALSE(parsed_version_q046.UsesTls());
+  EXPECT_TRUE(parsed_version_q046.UsesQuicCrypto());
 
   EXPECT_TRUE(parsed_version_draft_29.IsKnown());
   EXPECT_TRUE(parsed_version_draft_29.KnowsWhichDecrypterToUse());
@@ -91,8 +89,6 @@
   EXPECT_TRUE(parsed_version_draft_29.SupportsAntiAmplificationLimit());
   EXPECT_TRUE(parsed_version_draft_29.CanSendCoalescedPackets());
   EXPECT_FALSE(parsed_version_draft_29.SupportsGoogleAltSvcFormat());
-  EXPECT_TRUE(parsed_version_draft_29.HasIetfInvariantHeader());
-  EXPECT_TRUE(parsed_version_draft_29.SupportsMessageFrames());
   EXPECT_TRUE(parsed_version_draft_29.UsesHttp3());
   EXPECT_TRUE(parsed_version_draft_29.HasLongHeaderLengths());
   EXPECT_TRUE(parsed_version_draft_29.UsesCryptoFrames());
@@ -102,10 +98,8 @@
 }
 
 TEST(QuicVersionsTest, ParseQuicVersionLabel) {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync");
-  EXPECT_EQ(ParsedQuicVersion::Q043(),
-            ParseQuicVersionLabel(MakeVersionLabel('Q', '0', '4', '3')));
   EXPECT_EQ(ParsedQuicVersion::Q046(),
             ParseQuicVersionLabel(MakeVersionLabel('Q', '0', '4', '6')));
   EXPECT_EQ(ParsedQuicVersion::Q050(),
@@ -131,9 +125,8 @@
 }
 
 TEST(QuicVersionsTest, ParseQuicVersionString) {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync");
-  EXPECT_EQ(ParsedQuicVersion::Q043(), ParseQuicVersionString("Q043"));
   EXPECT_EQ(ParsedQuicVersion::Q046(),
             ParseQuicVersionString("QUIC_VERSION_46"));
   EXPECT_EQ(ParsedQuicVersion::Q046(), ParseQuicVersionString("46"));
@@ -224,9 +217,8 @@
 // CreateQuicVersionLabel() uses MakeVersionLabel() internally,
 // in case it has a bug.
 TEST(QuicVersionsTest, CreateQuicVersionLabel) {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync");
-  EXPECT_EQ(0x51303433u, CreateQuicVersionLabel(ParsedQuicVersion::Q043()));
   EXPECT_EQ(0x51303436u, CreateQuicVersionLabel(ParsedQuicVersion::Q046()));
   EXPECT_EQ(0x51303530u, CreateQuicVersionLabel(ParsedQuicVersion::Q050()));
   EXPECT_EQ(0xff00001du, CreateQuicVersionLabel(ParsedQuicVersion::Draft29()));
@@ -247,10 +239,8 @@
 }
 
 TEST(QuicVersionsTest, QuicVersionLabelToString) {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync");
-  EXPECT_EQ("Q043", QuicVersionLabelToString(
-                        CreateQuicVersionLabel(ParsedQuicVersion::Q043())));
   EXPECT_EQ("Q046", QuicVersionLabelToString(
                         CreateQuicVersionLabel(ParsedQuicVersion::Q046())));
   EXPECT_EQ("Q050", QuicVersionLabelToString(
@@ -285,10 +275,9 @@
 }
 
 TEST(QuicVersionsTest, ParseQuicVersionLabelString) {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync");
   // Explicitly test known QUIC version label strings.
-  EXPECT_EQ(ParsedQuicVersion::Q043(), ParseQuicVersionLabelString("Q043"));
   EXPECT_EQ(ParsedQuicVersion::Q046(), ParseQuicVersionLabelString("Q046"));
   EXPECT_EQ(ParsedQuicVersion::Q050(), ParseQuicVersionLabelString("Q050"));
   EXPECT_EQ(ParsedQuicVersion::Draft29(),
@@ -318,21 +307,21 @@
   EXPECT_EQ("QUIC_VERSION_UNSUPPORTED",
             QuicVersionToString(QUIC_VERSION_UNSUPPORTED));
 
-  QuicTransportVersion single_version[] = {QUIC_VERSION_43};
+  QuicTransportVersion single_version[] = {QUIC_VERSION_46};
   QuicTransportVersionVector versions_vector;
   for (size_t i = 0; i < ABSL_ARRAYSIZE(single_version); ++i) {
     versions_vector.push_back(single_version[i]);
   }
-  EXPECT_EQ("QUIC_VERSION_43",
+  EXPECT_EQ("QUIC_VERSION_46",
             QuicTransportVersionVectorToString(versions_vector));
 
   QuicTransportVersion multiple_versions[] = {QUIC_VERSION_UNSUPPORTED,
-                                              QUIC_VERSION_43};
+                                              QUIC_VERSION_46};
   versions_vector.clear();
   for (size_t i = 0; i < ABSL_ARRAYSIZE(multiple_versions); ++i) {
     versions_vector.push_back(multiple_versions[i]);
   }
-  EXPECT_EQ("QUIC_VERSION_UNSUPPORTED,QUIC_VERSION_43",
+  EXPECT_EQ("QUIC_VERSION_UNSUPPORTED,QUIC_VERSION_46",
             QuicTransportVersionVectorToString(versions_vector));
 
   // Make sure that all supported versions are present in QuicVersionToString.
@@ -343,12 +332,11 @@
 
   std::ostringstream os;
   os << versions_vector;
-  EXPECT_EQ("QUIC_VERSION_UNSUPPORTED,QUIC_VERSION_43", os.str());
+  EXPECT_EQ("QUIC_VERSION_UNSUPPORTED,QUIC_VERSION_46", os.str());
 }
 
 TEST(QuicVersionsTest, ParsedQuicVersionToString) {
   EXPECT_EQ("0", ParsedQuicVersionToString(ParsedQuicVersion::Unsupported()));
-  EXPECT_EQ("Q043", ParsedQuicVersionToString(ParsedQuicVersion::Q043()));
   EXPECT_EQ("Q046", ParsedQuicVersionToString(ParsedQuicVersion::Q046()));
   EXPECT_EQ("Q050", ParsedQuicVersionToString(ParsedQuicVersion::Q050()));
   EXPECT_EQ("draft29", ParsedQuicVersionToString(ParsedQuicVersion::Draft29()));
@@ -356,13 +344,13 @@
   EXPECT_EQ("V2Draft08",
             ParsedQuicVersionToString(ParsedQuicVersion::V2Draft08()));
 
-  ParsedQuicVersionVector versions_vector = {ParsedQuicVersion::Q043()};
-  EXPECT_EQ("Q043", ParsedQuicVersionVectorToString(versions_vector));
+  ParsedQuicVersionVector versions_vector = {ParsedQuicVersion::Q046()};
+  EXPECT_EQ("Q046", ParsedQuicVersionVectorToString(versions_vector));
 
   versions_vector = {ParsedQuicVersion::Unsupported(),
-                     ParsedQuicVersion::Q043()};
-  EXPECT_EQ("0,Q043", ParsedQuicVersionVectorToString(versions_vector));
-  EXPECT_EQ("0:Q043", ParsedQuicVersionVectorToString(versions_vector, ":",
+                     ParsedQuicVersion::Q046()};
+  EXPECT_EQ("0,Q046", ParsedQuicVersionVectorToString(versions_vector));
+  EXPECT_EQ("0:Q046", ParsedQuicVersionVectorToString(versions_vector, ":",
                                                       versions_vector.size()));
   EXPECT_EQ("0|...", ParsedQuicVersionVectorToString(versions_vector, "|", 0));
 
@@ -374,7 +362,7 @@
 
   std::ostringstream os;
   os << versions_vector;
-  EXPECT_EQ("0,Q043", os.str());
+  EXPECT_EQ("0,Q046", os.str());
 }
 
 TEST(QuicVersionsTest, FilterSupportedVersionsAllVersions) {
@@ -421,9 +409,8 @@
 // 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(QuicVersionsTest, CheckTransportVersionNumbersForTypos) {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync");
-  EXPECT_EQ(QUIC_VERSION_43, 43);
   EXPECT_EQ(QUIC_VERSION_46, 46);
   EXPECT_EQ(QUIC_VERSION_50, 50);
   EXPECT_EQ(QUIC_VERSION_IETF_DRAFT_29, 73);
@@ -432,9 +419,8 @@
 }
 
 TEST(QuicVersionsTest, AlpnForVersion) {
-  static_assert(SupportedVersions().size() == 6u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync");
-  EXPECT_EQ("h3-Q043", AlpnForVersion(ParsedQuicVersion::Q043()));
   EXPECT_EQ("h3-Q046", AlpnForVersion(ParsedQuicVersion::Q046()));
   EXPECT_EQ("h3-Q050", AlpnForVersion(ParsedQuicVersion::Q050()));
   EXPECT_EQ("h3-29", AlpnForVersion(ParsedQuicVersion::Draft29()));
diff --git a/quiche/quic/core/tls_chlo_extractor.h b/quiche/quic/core/tls_chlo_extractor.h
index d8c6b55..f24023b 100644
--- a/quiche/quic/core/tls_chlo_extractor.h
+++ b/quiche/quic/core/tls_chlo_extractor.h
@@ -77,7 +77,6 @@
   void OnError(QuicFramer* /*framer*/) override {}
   bool OnProtocolVersionMismatch(ParsedQuicVersion version) override;
   void OnPacket() override {}
-  void OnPublicResetPacket(const QuicPublicResetPacket& /*packet*/) override {}
   void OnVersionNegotiationPacket(
       const QuicVersionNegotiationPacket& /*packet*/) override {}
   void OnRetryPacket(QuicConnectionId /*original_connection_id*/,
diff --git a/quiche/quic/core/uber_received_packet_manager.cc b/quiche/quic/core/uber_received_packet_manager.cc
index 4efe788..ccfbc28 100644
--- a/quiche/quic/core/uber_received_packet_manager.cc
+++ b/quiche/quic/core/uber_received_packet_manager.cc
@@ -185,12 +185,6 @@
   return received_packet_managers_[packet_number_space].IsAckFrameEmpty();
 }
 
-QuicPacketNumber UberReceivedPacketManager::peer_least_packet_awaiting_ack()
-    const {
-  QUICHE_DCHECK(!supports_multiple_packet_number_spaces_);
-  return received_packet_managers_[0].peer_least_packet_awaiting_ack();
-}
-
 size_t UberReceivedPacketManager::min_received_before_ack_decimation() const {
   return received_packet_managers_[0].min_received_before_ack_decimation();
 }
diff --git a/quiche/quic/core/uber_received_packet_manager.h b/quiche/quic/core/uber_received_packet_manager.h
index 0e436c0..d4d35bc 100644
--- a/quiche/quic/core/uber_received_packet_manager.h
+++ b/quiche/quic/core/uber_received_packet_manager.h
@@ -74,8 +74,6 @@
   // Return true if ack frame of |packet_number_space| is empty.
   bool IsAckFrameEmpty(PacketNumberSpace packet_number_space) const;
 
-  QuicPacketNumber peer_least_packet_awaiting_ack() const;
-
   size_t min_received_before_ack_decimation() const;
   void set_min_received_before_ack_decimation(size_t new_value);
 
diff --git a/quiche/quic/qbone/qbone_client_test.cc b/quiche/quic/qbone/qbone_client_test.cc
index e893ddb..6429491 100644
--- a/quiche/quic/qbone/qbone_client_test.cc
+++ b/quiche/quic/qbone/qbone_client_test.cc
@@ -39,16 +39,7 @@
 ParsedQuicVersionVector GetTestParams() {
   ParsedQuicVersionVector test_versions;
   SetQuicReloadableFlag(quic_disable_version_q046, false);
-  // TODO(b/113130636): Make QBONE work with TLS.
-  for (const auto& version : CurrentSupportedVersionsWithQuicCrypto()) {
-    // QBONE requires MESSAGE frames
-    if (!version.SupportsMessageFrames()) {
-      continue;
-    }
-    test_versions.push_back(version);
-  }
-
-  return test_versions;
+  return CurrentSupportedVersionsWithQuicCrypto();
 }
 
 std::string TestPacketIn(const std::string& body) {
diff --git a/quiche/quic/qbone/qbone_session_test.cc b/quiche/quic/qbone/qbone_session_test.cc
index 3e2e8d1..1a9d023 100644
--- a/quiche/quic/qbone/qbone_session_test.cc
+++ b/quiche/quic/qbone/qbone_session_test.cc
@@ -49,18 +49,7 @@
 
 ParsedQuicVersionVector GetTestParams() {
   SetQuicReloadableFlag(quic_disable_version_q046, false);
-  ParsedQuicVersionVector test_versions;
-
-  // TODO(b/113130636): Make QBONE work with TLS.
-  for (const auto& version : CurrentSupportedVersionsWithQuicCrypto()) {
-    // QBONE requires MESSAGE frames
-    if (!version.SupportsMessageFrames()) {
-      continue;
-    }
-    test_versions.push_back(version);
-  }
-
-  return test_versions;
+  return CurrentSupportedVersionsWithQuicCrypto();
 }
 
 // Used by QuicCryptoServerConfig to provide server credentials, passes
diff --git a/quiche/quic/test_tools/fuzzing/quic_framer_process_data_packet_fuzzer.cc b/quiche/quic/test_tools/fuzzing/quic_framer_process_data_packet_fuzzer.cc
index 937708d..0ee8c23 100644
--- a/quiche/quic/test_tools/fuzzing/quic_framer_process_data_packet_fuzzer.cc
+++ b/quiche/quic/test_tools/fuzzing/quic_framer_process_data_packet_fuzzer.cc
@@ -47,11 +47,7 @@
 using quic::test::NoOpFramerVisitor;
 using quic::test::QuicFramerPeer;
 
-PacketHeaderFormat ConsumePacketHeaderFormat(FuzzedDataProvider* provider,
-                                             ParsedQuicVersion version) {
-  if (!version.HasIetfInvariantHeader()) {
-    return quic::GOOGLE_QUIC_PACKET;
-  }
+PacketHeaderFormat ConsumePacketHeaderFormat(FuzzedDataProvider* provider) {
   return provider->ConsumeBool() ? quic::IETF_QUIC_LONG_HEADER_PACKET
                                  : quic::IETF_QUIC_SHORT_HEADER_PACKET;
 }
@@ -59,7 +55,6 @@
 ParsedQuicVersion ConsumeParsedQuicVersion(FuzzedDataProvider* provider) {
   // TODO(wub): Add support for v49+.
   const QuicTransportVersion transport_versions[] = {
-      quic::QUIC_VERSION_43,
       quic::QUIC_VERSION_46,
   };
 
@@ -84,7 +79,7 @@
 
   header.version = ConsumeParsedQuicVersion(provider);
 
-  header.form = ConsumePacketHeaderFormat(provider, header.version);
+  header.form = ConsumePacketHeaderFormat(provider);
 
   const std::string cid_bytes =
       provider->ConsumeBytesAsString(kQuicDefaultConnectionIdLength);
@@ -235,8 +230,8 @@
     // Serialize the null-encrypted packet into |packet_buffer|.
     QuicDataWriter writer(packet_buffer.size(), packet_buffer.data());
     size_t length_field_offset = 0;
-    QUICHE_CHECK(sender_framer.AppendPacketHeader(header, &writer,
-                                                  &length_field_offset));
+    QUICHE_CHECK(sender_framer.AppendIetfPacketHeader(header, &writer,
+                                                      &length_field_offset));
 
     QUICHE_CHECK(
         writer.WriteBytes(payload_buffer.data(), payload_buffer.size()));
diff --git a/quiche/quic/test_tools/quic_connection_peer.cc b/quiche/quic/test_tools/quic_connection_peer.cc
index fbecdd3..8ac35d5 100644
--- a/quiche/quic/test_tools/quic_connection_peer.cc
+++ b/quiche/quic/test_tools/quic_connection_peer.cc
@@ -30,12 +30,6 @@
 }
 
 // static
-void QuicConnectionPeer::PopulateStopWaitingFrame(
-    QuicConnection* connection, QuicStopWaitingFrame* stop_waiting) {
-  connection->PopulateStopWaitingFrame(stop_waiting);
-}
-
-// static
 QuicPacketCreator* QuicConnectionPeer::GetPacketCreator(
     QuicConnection* connection) {
   return &connection->packet_creator_;
@@ -276,17 +270,6 @@
 }
 
 // static
-bool QuicConnectionPeer::GetNoStopWaitingFrames(QuicConnection* connection) {
-  return connection->no_stop_waiting_frames_;
-}
-
-// static
-void QuicConnectionPeer::SetNoStopWaitingFrames(QuicConnection* connection,
-                                                bool no_stop_waiting_frames) {
-  connection->no_stop_waiting_frames_ = no_stop_waiting_frames;
-}
-
-// static
 void QuicConnectionPeer::SetMaxTrackedPackets(
     QuicConnection* connection, QuicPacketCount max_tracked_packets) {
   connection->max_tracked_packets_ = max_tracked_packets;
diff --git a/quiche/quic/test_tools/quic_connection_peer.h b/quiche/quic/test_tools/quic_connection_peer.h
index cf8a5a6..3c8e068 100644
--- a/quiche/quic/test_tools/quic_connection_peer.h
+++ b/quiche/quic/test_tools/quic_connection_peer.h
@@ -42,9 +42,6 @@
   static void SetLossAlgorithm(QuicConnection* connection,
                                LossDetectionInterface* loss_algorithm);
 
-  static void PopulateStopWaitingFrame(QuicConnection* connection,
-                                       QuicStopWaitingFrame* stop_waiting);
-
   static QuicPacketCreator* GetPacketCreator(QuicConnection* connection);
 
   static QuicSentPacketManager* GetSentPacketManager(
@@ -122,9 +119,6 @@
                                     float ack_decimation_delay);
   static bool HasRetransmittableFrames(QuicConnection* connection,
                                        uint64_t packet_number);
-  static bool GetNoStopWaitingFrames(QuicConnection* connection);
-  static void SetNoStopWaitingFrames(QuicConnection* connection,
-                                     bool no_stop_waiting_frames);
   static void SetMaxTrackedPackets(QuicConnection* connection,
                                    QuicPacketCount max_tracked_packets);
   static void SetNegotiatedVersion(QuicConnection* connection);
diff --git a/quiche/quic/test_tools/quic_packet_creator_peer.cc b/quiche/quic/test_tools/quic_packet_creator_peer.cc
index 2ab9fb0..f7f75ba 100644
--- a/quiche/quic/test_tools/quic_packet_creator_peer.cc
+++ b/quiche/quic/test_tools/quic_packet_creator_peer.cc
@@ -19,12 +19,6 @@
 // static
 void QuicPacketCreatorPeer::SetSendVersionInPacket(
     QuicPacketCreator* creator, bool send_version_in_packet) {
-  ParsedQuicVersion version = creator->framer_->version();
-  if (!VersionHasIetfQuicFrames(version.transport_version) &&
-      version.handshake_protocol != PROTOCOL_TLS1_3) {
-    creator->send_version_in_packet_ = send_version_in_packet;
-    return;
-  }
   if (!send_version_in_packet) {
     creator->packet_.encryption_level = ENCRYPTION_FORWARD_SECURE;
     return;
diff --git a/quiche/quic/test_tools/quic_test_utils.h b/quiche/quic/test_tools/quic_test_utils.h
index 25cc2d4..7b5667a 100644
--- a/quiche/quic/test_tools/quic_test_utils.h
+++ b/quiche/quic/test_tools/quic_test_utils.h
@@ -277,8 +277,6 @@
   MOCK_METHOD(bool, OnProtocolVersionMismatch, (ParsedQuicVersion version),
               (override));
   MOCK_METHOD(void, OnPacket, (), (override));
-  MOCK_METHOD(void, OnPublicResetPacket, (const QuicPublicResetPacket& header),
-              (override));
   MOCK_METHOD(void, OnVersionNegotiationPacket,
               (const QuicVersionNegotiationPacket& packet), (override));
   MOCK_METHOD(void, OnRetryPacket,
@@ -371,7 +369,6 @@
 
   void OnError(QuicFramer* /*framer*/) override {}
   void OnPacket() override {}
-  void OnPublicResetPacket(const QuicPublicResetPacket& /*packet*/) override {}
   void OnVersionNegotiationPacket(
       const QuicVersionNegotiationPacket& /*packet*/) override {}
   void OnRetryPacket(QuicConnectionId /*original_connection_id*/,
@@ -1348,9 +1345,6 @@
 
   MOCK_METHOD(void, OnCryptoFrame, (const QuicCryptoFrame&), (override));
 
-  MOCK_METHOD(void, OnStopWaitingFrame, (const QuicStopWaitingFrame&),
-              (override));
-
   MOCK_METHOD(void, OnRstStreamFrame, (const QuicRstStreamFrame&), (override));
 
   MOCK_METHOD(void, OnConnectionCloseFrame, (const QuicConnectionCloseFrame&),
@@ -1377,9 +1371,6 @@
   MOCK_METHOD(void, OnPathResponseFrame, (const QuicPathResponseFrame&),
               (override));
 
-  MOCK_METHOD(void, OnPublicResetPacket, (const QuicPublicResetPacket&),
-              (override));
-
   MOCK_METHOD(void, OnVersionNegotiationPacket,
               (const QuicVersionNegotiationPacket&), (override));
 
diff --git a/quiche/quic/test_tools/simple_quic_framer.cc b/quiche/quic/test_tools/simple_quic_framer.cc
index 33a56ef..b13fec4 100644
--- a/quiche/quic/test_tools/simple_quic_framer.cc
+++ b/quiche/quic/test_tools/simple_quic_framer.cc
@@ -31,9 +31,6 @@
   }
 
   void OnPacket() override {}
-  void OnPublicResetPacket(const QuicPublicResetPacket& packet) override {
-    public_reset_packet_ = std::make_unique<QuicPublicResetPacket>((packet));
-  }
   void OnVersionNegotiationPacket(
       const QuicVersionNegotiationPacket& packet) override {
     version_negotiation_packet_ =
@@ -292,7 +289,6 @@
   bool has_header_;
   QuicPacketHeader header_;
   std::unique_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_;
-  std::unique_ptr<QuicPublicResetPacket> public_reset_packet_;
   std::unique_ptr<QuicIetfStatelessResetPacket> stateless_reset_packet_;
   std::vector<QuicAckFrame> ack_frames_;
   std::vector<QuicStopWaitingFrame> stop_waiting_frames_;
diff --git a/quiche/quic/tools/quic_packet_printer_bin.cc b/quiche/quic/tools/quic_packet_printer_bin.cc
index 92a3c4c..ca1b433 100644
--- a/quiche/quic/tools/quic_packet_printer_bin.cc
+++ b/quiche/quic/tools/quic_packet_printer_bin.cc
@@ -57,9 +57,6 @@
     return true;
   }
   void OnPacket() override { std::cerr << "OnPacket\n"; }
-  void OnPublicResetPacket(const QuicPublicResetPacket& /*packet*/) override {
-    std::cerr << "OnPublicResetPacket\n";
-  }
   void OnVersionNegotiationPacket(
       const QuicVersionNegotiationPacket& /*packet*/) override {
     std::cerr << "OnVersionNegotiationPacket\n";