diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index 2d0fa34..be5c5ee 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -726,7 +726,6 @@
 }
 
 TEST_P(EndToEndTest, SimpleRequestResponseForcedVersionNegotiation) {
-  SetQuicReloadableFlag(quic_use_parse_public_header, true);
   client_supported_versions_.insert(client_supported_versions_.begin(),
                                     QuicVersionReservedForNegotiation());
   ASSERT_TRUE(Initialize());
@@ -739,7 +738,6 @@
 }
 
 TEST_P(EndToEndTestWithTls, ForcedVersionNegotiation) {
-  SetQuicReloadableFlag(quic_use_parse_public_header, true);
   client_supported_versions_.insert(client_supported_versions_.begin(),
                                     QuicVersionReservedForNegotiation());
   ASSERT_TRUE(Initialize());
@@ -846,7 +844,6 @@
     ASSERT_TRUE(Initialize());
     return;
   }
-  SetQuicReloadableFlag(quic_use_parse_public_header, true);
   client_supported_versions_.insert(client_supported_versions_.begin(),
                                     QuicVersionReservedForNegotiation());
   override_client_connection_id_length_ = kQuicDefaultConnectionIdLength;
@@ -867,7 +864,6 @@
     ASSERT_TRUE(Initialize());
     return;
   }
-  SetQuicReloadableFlag(quic_use_parse_public_header, true);
   client_supported_versions_.insert(client_supported_versions_.begin(),
                                     QuicVersionReservedForNegotiation());
   override_server_connection_id_length_ = 9;
diff --git a/quic/core/quic_dispatcher.cc b/quic/core/quic_dispatcher.cc
index b130fe9..eec468a 100644
--- a/quic/core/quic_dispatcher.cc
+++ b/quic/core/quic_dispatcher.cc
@@ -266,34 +266,21 @@
                        QuicStringPiece(packet.data(), packet.length()));
   ReceivedPacketInfo packet_info(self_address, peer_address, packet);
   std::string detailed_error;
-  QuicErrorCode error;
-  if (!GetQuicReloadableFlag(quic_use_parse_public_header)) {
-    error = QuicFramer::ProcessPacketDispatcher(
-        packet, expected_server_connection_id_length_, &packet_info.form,
-        &packet_info.version_flag, &packet_info.version_label,
-        &packet_info.destination_connection_id,
-        &packet_info.source_connection_id, &detailed_error);
-  } else {
-    QUIC_RELOADABLE_FLAG_COUNT(quic_use_parse_public_header);
-    bool retry_token_present;
-    QuicStringPiece retry_token;
-    error = QuicFramer::ParsePublicHeaderDispatcher(
-        packet, expected_server_connection_id_length_, &packet_info.form,
-        &packet_info.long_packet_type, &packet_info.version_flag,
-        &packet_info.use_length_prefix, &packet_info.version_label,
-        &packet_info.version, &packet_info.destination_connection_id,
-        &packet_info.source_connection_id, &retry_token_present, &retry_token,
-        &detailed_error);
-  }
+  bool retry_token_present;
+  QuicStringPiece retry_token;
+  const QuicErrorCode error = QuicFramer::ParsePublicHeaderDispatcher(
+      packet, expected_server_connection_id_length_, &packet_info.form,
+      &packet_info.long_packet_type, &packet_info.version_flag,
+      &packet_info.use_length_prefix, &packet_info.version_label,
+      &packet_info.version, &packet_info.destination_connection_id,
+      &packet_info.source_connection_id, &retry_token_present, &retry_token,
+      &detailed_error);
   if (error != QUIC_NO_ERROR) {
     // Packet has framing error.
     SetLastError(error);
     QUIC_DLOG(ERROR) << detailed_error;
     return;
   }
-  if (!GetQuicReloadableFlag(quic_use_parse_public_header)) {
-    packet_info.version = ParseQuicVersionLabel(packet_info.version_label);
-  }
   if (packet_info.destination_connection_id.length() !=
           expected_server_connection_id_length_ &&
       !should_update_expected_server_connection_id_length_ &&
@@ -477,8 +464,7 @@
       return true;
     }
 
-    if (GetQuicReloadableFlag(quic_use_parse_public_header) &&
-        GetQuicReloadableFlag(quic_donot_process_small_initial_packets) &&
+    if (GetQuicReloadableFlag(quic_donot_process_small_initial_packets) &&
         crypto_config()->validate_chlo_size() &&
         packet_info.form == IETF_QUIC_LONG_HEADER_PACKET &&
         packet_info.long_packet_type == INITIAL &&
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index 2c757a4..48a1aa6 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -529,7 +529,6 @@
 }
 
 TEST_F(QuicDispatcherTest, StatelessVersionNegotiation) {
-  SetQuicReloadableFlag(quic_use_parse_public_header, true);
   CreateTimeWaitListManager();
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
 
@@ -548,7 +547,6 @@
 }
 
 TEST_F(QuicDispatcherTest, StatelessVersionNegotiationWithClientConnectionId) {
-  SetQuicReloadableFlag(quic_use_parse_public_header, true);
   CreateTimeWaitListManager();
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
 
@@ -589,7 +587,6 @@
 // Disabling CHLO size validation allows the dispatcher to send version
 // negotiation packets in response to a CHLO that is otherwise too small.
 TEST_F(QuicDispatcherTest, VersionNegotiationWithoutChloSizeValidation) {
-  SetQuicReloadableFlag(quic_use_parse_public_header, true);
   crypto_config_.set_validate_chlo_size(false);
 
   CreateTimeWaitListManager();
@@ -933,7 +930,6 @@
 }
 
 TEST_F(QuicDispatcherTest, SupportedTransportVersionsChangeInFlight) {
-  SetQuicReloadableFlag(quic_use_parse_public_header, true);
   static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 7u,
                 "Supported versions out of sync");
   SetQuicReloadableFlag(quic_disable_version_39, false);
@@ -1048,7 +1044,6 @@
 
 TEST_F(QuicDispatcherTest, VersionNegotiationProbe) {
   SetQuicFlag(FLAGS_quic_prober_uses_length_prefixed_connection_ids, true);
-  SetQuicReloadableFlag(quic_use_parse_public_header, true);
   SetQuicReloadableFlag(quic_use_length_prefix_from_packet_info, true);
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
   CreateTimeWaitListManager();
@@ -1148,7 +1143,6 @@
 
 TEST_F(QuicDispatcherTest, VersionNegotiationProbeEndToEnd) {
   SetQuicFlag(FLAGS_quic_prober_uses_length_prefixed_connection_ids, true);
-  SetQuicReloadableFlag(quic_use_parse_public_header, true);
   SetQuicReloadableFlag(quic_use_length_prefix_from_packet_info, true);
 
   SavingWriter* saving_writer = new SavingWriter();
@@ -1344,7 +1338,6 @@
 
 TEST_F(QuicDispatcherTest, DoNotProcessSmallPacket) {
   SetQuicReloadableFlag(quic_donot_process_small_initial_packets, true);
-  SetQuicReloadableFlag(quic_use_parse_public_header, true);
   CreateTimeWaitListManager();
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
 
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 6b55cfc..f792273 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -6234,87 +6234,6 @@
 }
 
 // static
-QuicErrorCode QuicFramer::ProcessPacketDispatcher(
-    const QuicEncryptedPacket& packet,
-    uint8_t expected_destination_connection_id_length,
-    PacketHeaderFormat* format,
-    bool* version_flag,
-    QuicVersionLabel* version_label,
-    QuicConnectionId* destination_connection_id,
-    QuicConnectionId* source_connection_id,
-    std::string* detailed_error) {
-  DCHECK(!GetQuicReloadableFlag(quic_use_parse_public_header));
-  QuicDataReader reader(packet.data(), packet.length());
-
-  *source_connection_id = EmptyQuicConnectionId();
-  uint8_t first_byte;
-  if (!reader.ReadBytes(&first_byte, 1)) {
-    *detailed_error = "Unable to read first byte.";
-    return QUIC_INVALID_PACKET_HEADER;
-  }
-  uint8_t destination_connection_id_length = 0, source_connection_id_length = 0;
-  if (!QuicUtils::IsIetfPacketHeader(first_byte)) {
-    *format = GOOGLE_QUIC_PACKET;
-    *version_flag = (first_byte & PACKET_PUBLIC_FLAGS_VERSION) != 0;
-    destination_connection_id_length =
-        first_byte & PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID;
-    if (destination_connection_id_length == 0 ||
-        !reader.ReadConnectionId(destination_connection_id,
-                                 destination_connection_id_length)) {
-      *detailed_error = "Unable to read ConnectionId.";
-      return QUIC_INVALID_PACKET_HEADER;
-    }
-    if (*version_flag && !ProcessVersionLabel(&reader, version_label)) {
-      *detailed_error = "Unable to read protocol version.";
-      return QUIC_INVALID_PACKET_HEADER;
-    }
-    return QUIC_NO_ERROR;
-  }
-
-  *format = GetIetfPacketHeaderFormat(first_byte);
-  QUIC_DVLOG(1) << "Dispatcher: Processing IETF QUIC packet, format: "
-                << *format;
-  *version_flag = *format == IETF_QUIC_LONG_HEADER_PACKET;
-  if (*format == IETF_QUIC_LONG_HEADER_PACKET) {
-    if (!ProcessVersionLabel(&reader, version_label)) {
-      *detailed_error = "Unable to read protocol version.";
-      return QUIC_INVALID_PACKET_HEADER;
-    }
-    // Set should_update_expected_server_connection_id_length to true to bypass
-    // connection ID lengths validation.
-    uint8_t unused_expected_server_connection_id_length = 0;
-    if (!ProcessAndValidateIetfConnectionIdLength(
-            &reader, ParseQuicVersionLabel(*version_label),
-            Perspective::IS_SERVER,
-            /*should_update_expected_server_connection_id_length=*/true,
-            &unused_expected_server_connection_id_length,
-            &destination_connection_id_length, &source_connection_id_length,
-            detailed_error)) {
-      return QUIC_INVALID_PACKET_HEADER;
-    }
-  } else {
-    // For short header packets, expected_destination_connection_id_length
-    // is used to determine the destination_connection_id_length.
-    destination_connection_id_length =
-        expected_destination_connection_id_length;
-    DCHECK_EQ(0, source_connection_id_length);
-  }
-  // Read destination connection ID.
-  if (!reader.ReadConnectionId(destination_connection_id,
-                               destination_connection_id_length)) {
-    *detailed_error = "Unable to read destination connection ID.";
-    return QUIC_INVALID_PACKET_HEADER;
-  }
-  // Read source connection ID.
-  if (!reader.ReadConnectionId(source_connection_id,
-                               source_connection_id_length)) {
-    *detailed_error = "Unable to read source connection ID.";
-    return QUIC_INVALID_PACKET_HEADER;
-  }
-  return QUIC_NO_ERROR;
-}
-
-// static
 QuicErrorCode QuicFramer::ParsePublicHeaderDispatcher(
     const QuicEncryptedPacket& packet,
     uint8_t expected_destination_connection_id_length,
diff --git a/quic/core/quic_framer.h b/quic/core/quic_framer.h
index 3d4c063..8421c10 100644
--- a/quic/core/quic_framer.h
+++ b/quic/core/quic_framer.h
@@ -380,21 +380,6 @@
       uint64_t retry_token_length,
       QuicVariableLengthIntegerLength length_length);
 
-  // Lightweight parsing of |packet| and populates |format|, |version_flag|,
-  // |version_label|, |destination_connection_id|, |source_connection_id| and
-  // |detailed_error|. Please note, |expected_destination_connection_id_length|
-  // is only used to determine IETF short header packet's destination
-  // connection ID length.
-  static QuicErrorCode ProcessPacketDispatcher(
-      const QuicEncryptedPacket& packet,
-      uint8_t expected_destination_connection_id_length,
-      PacketHeaderFormat* format,
-      bool* version_flag,
-      QuicVersionLabel* version_label,
-      QuicConnectionId* destination_connection_id,
-      QuicConnectionId* source_connection_id,
-      std::string* detailed_error);
-
   // Parses the unencryoted fields in a QUIC header using |reader| as input,
   // stores the result in the other parameters.
   // |expected_destination_connection_id_length| is only used for short headers.
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index e15633f..646e9ee 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -1021,24 +1021,16 @@
   QuicConnectionId destination_connection_id, source_connection_id;
   QuicVersionLabel version_label;
   std::string detailed_error;
-  QuicErrorCode error_code;
-  if (!GetQuicReloadableFlag(quic_use_parse_public_header)) {
-    error_code = QuicFramer::ProcessPacketDispatcher(
-        *encrypted, kQuicDefaultConnectionIdLength, &format, &version_flag,
-        &version_label, &destination_connection_id, &source_connection_id,
-        &detailed_error);
-  } else {
-    bool retry_token_present, use_length_prefix;
-    QuicStringPiece retry_token;
-    ParsedQuicVersion parsed_version = UnsupportedQuicVersion();
-    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_present,
-        &retry_token, &detailed_error);
-    EXPECT_FALSE(retry_token_present);
-    EXPECT_FALSE(use_length_prefix);
-  }
+  bool retry_token_present, use_length_prefix;
+  QuicStringPiece 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_present,
+      &retry_token, &detailed_error);
+  EXPECT_FALSE(retry_token_present);
+  EXPECT_FALSE(use_length_prefix);
   EXPECT_EQ(QUIC_NO_ERROR, error_code);
   EXPECT_EQ(GOOGLE_QUIC_PACKET, format);
   EXPECT_FALSE(version_flag);
@@ -1050,9 +1042,9 @@
 TEST_P(QuicFramerTest, LongPacketHeader) {
   // clang-format off
   PacketFragments packet46 = {
-    // type (long header with packet type INITIAL)
+    // type (long header with packet type ZERO_RTT)
     {"Unable to read first byte.",
-     {0xC3}},
+     {0xD3}},
     // version tag
     {"Unable to read protocol version.",
      {QUIC_VERSION_BYTES}},
@@ -1073,6 +1065,7 @@
     return;
   }
 
+  SetDecrypterLevel(ENCRYPTION_ZERO_RTT);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(packet46));
 
@@ -1093,24 +1086,18 @@
   QuicConnectionId destination_connection_id, source_connection_id;
   QuicVersionLabel version_label;
   std::string detailed_error;
-  QuicErrorCode error_code;
-  if (!GetQuicReloadableFlag(quic_use_parse_public_header)) {
-    error_code = QuicFramer::ProcessPacketDispatcher(
-        *encrypted, kQuicDefaultConnectionIdLength, &format, &version_flag,
-        &version_label, &destination_connection_id, &source_connection_id,
-        &detailed_error);
-  } else {
-    bool retry_token_present, use_length_prefix;
-    QuicStringPiece retry_token;
-    ParsedQuicVersion parsed_version = UnsupportedQuicVersion();
-    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_present,
-        &retry_token, &detailed_error);
-    EXPECT_EQ(retry_token_present, framer_.version().SupportsRetry());
-    EXPECT_FALSE(use_length_prefix);
-  }
+  bool retry_token_present, use_length_prefix;
+  QuicStringPiece 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_present,
+      &retry_token, &detailed_error);
+  EXPECT_EQ(QUIC_NO_ERROR, error_code);
+  EXPECT_EQ("", detailed_error);
+  EXPECT_FALSE(retry_token_present);
+  EXPECT_FALSE(use_length_prefix);
   EXPECT_EQ(IETF_QUIC_LONG_HEADER_PACKET, format);
   EXPECT_TRUE(version_flag);
   EXPECT_EQ(kQuicDefaultConnectionIdLength, destination_connection_id.length());
@@ -1123,7 +1110,6 @@
     // This test requires an IETF long header.
     return;
   }
-  SetQuicReloadableFlag(quic_use_parse_public_header, false);
   SetDecrypterLevel(ENCRYPTION_ZERO_RTT);
   // clang-format off
   unsigned char packet[] = {
@@ -1138,6 +1124,25 @@
     0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
     // source connection ID
     0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x11,
+    // packet number
+    0x12, 0x34, 0x56, 0x00,
+    // padding frame
+    0x00,
+  };
+  unsigned char packet49[] = {
+    // public flags (long header with packet type ZERO_RTT_PROTECTED and
+    // 4-byte packet number)
+    0xD3,
+    // version
+    QUIC_VERSION_BYTES,
+    // destination connection ID length
+    0x08,
+    // destination connection ID
+    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
+    // source connection ID length
+    0x08,
+    // source connection ID
+    0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x11,
     // long header packet length
     0x05,
     // packet number
@@ -1147,31 +1152,32 @@
   };
   // clang-format on
 
-  QuicEncryptedPacket encrypted(AsChars(packet), QUIC_ARRAYSIZE(packet), false);
+  unsigned char* p = packet;
+  size_t p_length = QUIC_ARRAYSIZE(packet);
+  if (framer_.transport_version() >= QUIC_VERSION_49) {
+    p = packet49;
+    p_length = QUIC_ARRAYSIZE(packet49);
+  }
+
+  QuicEncryptedPacket encrypted(AsChars(p), p_length, false);
   PacketHeaderFormat format = GOOGLE_QUIC_PACKET;
   QuicLongHeaderType long_packet_type = INVALID_PACKET_TYPE;
   bool version_flag = false;
   QuicConnectionId destination_connection_id, source_connection_id;
   QuicVersionLabel version_label = 0;
   std::string detailed_error = "";
-  QuicErrorCode error_code;
-  if (!GetQuicReloadableFlag(quic_use_parse_public_header)) {
-    error_code = QuicFramer::ProcessPacketDispatcher(
-        encrypted, kQuicDefaultConnectionIdLength, &format, &version_flag,
-        &version_label, &destination_connection_id, &source_connection_id,
-        &detailed_error);
-  } else {
-    bool retry_token_present, use_length_prefix;
-    QuicStringPiece retry_token;
-    ParsedQuicVersion parsed_version = UnsupportedQuicVersion();
-    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_present,
-        &retry_token, &detailed_error);
-    EXPECT_FALSE(retry_token_present);
-    EXPECT_FALSE(use_length_prefix);
-  }
+  bool retry_token_present, use_length_prefix;
+  QuicStringPiece 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_present,
+      &retry_token, &detailed_error);
+  EXPECT_EQ(QUIC_NO_ERROR, error_code);
+  EXPECT_FALSE(retry_token_present);
+  EXPECT_EQ(framer_.version().HasLengthPrefixedConnectionIds(),
+            use_length_prefix);
   EXPECT_EQ("", detailed_error);
   EXPECT_EQ(IETF_QUIC_LONG_HEADER_PACKET, format);
   EXPECT_TRUE(version_flag);
diff --git a/quic/core/quic_packets.h b/quic/core/quic_packets.h
index 7faa741..82647c6 100644
--- a/quic/core/quic_packets.h
+++ b/quic/core/quic_packets.h
@@ -435,7 +435,6 @@
   const QuicSocketAddress& peer_address;
   const QuicReceivedPacket& packet;
 
-  // Fields below are populated by QuicFramer::ProcessPacketDispatcher.
   PacketHeaderFormat form;
   // This is only used if the form is IETF_QUIC_LONG_HEADER_PACKET.
   QuicLongHeaderType long_packet_type;
diff --git a/quic/core/quic_version_manager_test.cc b/quic/core/quic_version_manager_test.cc
index c8e4807..b73b729 100644
--- a/quic/core/quic_version_manager_test.cc
+++ b/quic/core/quic_version_manager_test.cc
@@ -48,7 +48,6 @@
             manager.GetSupportedTransportVersions());
 
   SetQuicReloadableFlag(quic_enable_version_49, true);
-  SetQuicReloadableFlag(quic_use_parse_public_header, true);
   EXPECT_EQ(QuicTransportVersionVector({QUIC_VERSION_49, QUIC_VERSION_48,
                                         QUIC_VERSION_47, QUIC_VERSION_46,
                                         QUIC_VERSION_43, QUIC_VERSION_39}),
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index 223780b..1247eaf 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -265,13 +265,11 @@
       continue;
     }
     if (version.transport_version == QUIC_VERSION_99) {
-      if (GetQuicReloadableFlag(quic_enable_version_99) &&
-          GetQuicReloadableFlag(quic_use_parse_public_header)) {
+      if (GetQuicReloadableFlag(quic_enable_version_99)) {
         filtered_versions.push_back(version);
       }
     } else if (version.transport_version == QUIC_VERSION_49) {
-      if (GetQuicReloadableFlag(quic_enable_version_49) &&
-          GetQuicReloadableFlag(quic_use_parse_public_header)) {
+      if (GetQuicReloadableFlag(quic_enable_version_49)) {
         filtered_versions.push_back(version);
       }
     } else if (version.transport_version == QUIC_VERSION_48) {
@@ -474,7 +472,6 @@
   // Enable necessary flags.
   SetQuicReloadableFlag(quic_supports_tls_handshake, true);
   SetQuicReloadableFlag(quic_simplify_stop_waiting, true);
-  SetQuicReloadableFlag(quic_use_parse_public_header, true);
   SetQuicRestartFlag(quic_use_hashed_stateless_reset_tokens, true);
 }
 
diff --git a/quic/core/quic_versions_test.cc b/quic/core/quic_versions_test.cc
index a037639..1ab12e5 100644
--- a/quic/core/quic_versions_test.cc
+++ b/quic/core/quic_versions_test.cc
@@ -300,7 +300,6 @@
   SetQuicReloadableFlag(quic_enable_version_48_2, true);
   SetQuicReloadableFlag(quic_enable_version_49, true);
   SetQuicReloadableFlag(quic_enable_version_99, true);
-  SetQuicReloadableFlag(quic_use_parse_public_header, true);
   ParsedQuicVersionVector parsed_versions;
   for (QuicTransportVersion version : all_versions) {
     parsed_versions.push_back(ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, version));
@@ -327,7 +326,6 @@
   SetQuicReloadableFlag(quic_enable_version_48_2, true);
   SetQuicReloadableFlag(quic_enable_version_49, true);
   SetQuicReloadableFlag(quic_enable_version_99, false);
-  SetQuicReloadableFlag(quic_use_parse_public_header, true);
   ParsedQuicVersionVector parsed_versions;
   for (QuicTransportVersion version : all_versions) {
     parsed_versions.push_back(ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, version));
diff --git a/quic/qbone/qbone_client_test.cc b/quic/qbone/qbone_client_test.cc
index 2902b19..cb197a2 100644
--- a/quic/qbone/qbone_client_test.cc
+++ b/quic/qbone/qbone_client_test.cc
@@ -206,7 +206,6 @@
 };
 
 TEST(QboneClientTest, SendDataFromClient) {
-  SetQuicReloadableFlag(quic_use_parse_public_header, true);
   auto server = new QboneTestServer(crypto_test_utils::ProofSourceForTesting());
   QuicSocketAddress server_address(TestLoopback(),
                                    QuicPickServerPortForTestsOrDie());