diff --git a/quic/core/crypto/crypto_utils.cc b/quic/core/crypto/crypto_utils.cc
index 5c0c851..f8eb06a 100644
--- a/quic/core/crypto/crypto_utils.cc
+++ b/quic/core/crypto/crypto_utils.cc
@@ -207,7 +207,7 @@
                                   absl::string_view* nonce) {
   static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync with retry integrity keys");
-  if (!version.HasRetryIntegrityTag()) {
+  if (!version.UsesTls()) {
     QUIC_BUG << "Attempted to get retry integrity keys for invalid version "
              << version;
     return false;
diff --git a/quic/core/crypto/transport_parameters.cc b/quic/core/crypto/transport_parameters.cc
index a3a3d0e..e9558a3 100644
--- a/quic/core/crypto/transport_parameters.cc
+++ b/quic/core/crypto/transport_parameters.cc
@@ -55,14 +55,14 @@
   kInitialRoundTripTime = 0x3127,
   kGoogleConnectionOptions = 0x3128,
   kGoogleUserAgentId = 0x3129,
-  kGoogleSupportHandshakeDone = 0x312A,  // Only used in T050.
+  // 0x312A was used only in T050 to indicate support for HANDSHAKE_DONE.
   kGoogleKeyUpdateNotYetSupported = 0x312B,
   // 0x4751 was used for non-standard Google-specific parameters encoded as a
   // Google QUIC_CRYPTO CHLO, it has been replaced by individual parameters.
   kGoogleQuicVersion =
       0x4752,  // Used to transmit version and supported_versions.
 
-  kMinAckDelay = 0xDE1A  // draft-iyengar-quic-delayed-ack.
+  kMinAckDelay = 0xDE1A,  // draft-iyengar-quic-delayed-ack.
 };
 
 namespace {
@@ -124,8 +124,6 @@
       return "google_connection_options";
     case TransportParameters::kGoogleUserAgentId:
       return "user_agent_id";
-    case TransportParameters::kGoogleSupportHandshakeDone:
-      return "support_handshake_done";
     case TransportParameters::kGoogleKeyUpdateNotYetSupported:
       return "key_update_not_yet_supported";
     case TransportParameters::kGoogleQuicVersion:
@@ -160,7 +158,6 @@
     case TransportParameters::kInitialRoundTripTime:
     case TransportParameters::kGoogleConnectionOptions:
     case TransportParameters::kGoogleUserAgentId:
-    case TransportParameters::kGoogleSupportHandshakeDone:
     case TransportParameters::kGoogleKeyUpdateNotYetSupported:
     case TransportParameters::kGoogleQuicVersion:
     case TransportParameters::kMinAckDelay:
@@ -169,87 +166,6 @@
   return false;
 }
 
-bool WriteTransportParameterId(
-    QuicDataWriter* writer,
-    TransportParameters::TransportParameterId param_id,
-    ParsedQuicVersion version) {
-  if (version.HasVarIntTransportParams()) {
-    if (!writer->WriteVarInt62(param_id)) {
-      QUIC_BUG << "Failed to write param_id for "
-               << TransportParameterIdToString(param_id);
-      return false;
-    }
-  } else {
-    if (static_cast<uint64_t>(param_id) >
-        std::numeric_limits<uint16_t>::max()) {
-      QUIC_BUG << "Cannot serialize transport parameter "
-               << TransportParameterIdToString(param_id) << " with version "
-               << version;
-      return false;
-    }
-    if (!writer->WriteUInt16(param_id)) {
-      QUIC_BUG << "Failed to write param_id16 for "
-               << TransportParameterIdToString(param_id);
-      return false;
-    }
-  }
-  return true;
-}
-
-bool WriteTransportParameterLength(QuicDataWriter* writer,
-                                   uint64_t length,
-                                   ParsedQuicVersion version) {
-  if (version.HasVarIntTransportParams()) {
-    return writer->WriteVarInt62(length);
-  }
-  if (length > std::numeric_limits<uint16_t>::max()) {
-    QUIC_BUG << "Cannot serialize transport parameter length " << length
-             << " with version " << version;
-    return false;
-  }
-  return writer->WriteUInt16(length);
-}
-
-bool WriteTransportParameterStringPiece(QuicDataWriter* writer,
-                                        absl::string_view value,
-                                        ParsedQuicVersion version) {
-  if (version.HasVarIntTransportParams()) {
-    return writer->WriteStringPieceVarInt62(value);
-  }
-  return writer->WriteStringPiece16(value);
-}
-
-bool ReadTransportParameterId(
-    QuicDataReader* reader,
-    ParsedQuicVersion version,
-    TransportParameters::TransportParameterId* out_param_id) {
-  if (version.HasVarIntTransportParams()) {
-    uint64_t param_id64;
-    if (!reader->ReadVarInt62(&param_id64)) {
-      return false;
-    }
-    *out_param_id =
-        static_cast<TransportParameters::TransportParameterId>(param_id64);
-  } else {
-    uint16_t param_id16;
-    if (!reader->ReadUInt16(&param_id16)) {
-      return false;
-    }
-    *out_param_id =
-        static_cast<TransportParameters::TransportParameterId>(param_id16);
-  }
-  return true;
-}
-
-bool ReadTransportParameterLengthAndValue(QuicDataReader* reader,
-                                          ParsedQuicVersion version,
-                                          absl::string_view* out_value) {
-  if (version.HasVarIntTransportParams()) {
-    return reader->ReadStringPieceVarInt62(out_value);
-  }
-  return reader->ReadStringPiece16(out_value);
-}
-
 }  // namespace
 
 TransportParameters::IntegerParameter::IntegerParameter(
@@ -289,29 +205,21 @@
 }
 
 bool TransportParameters::IntegerParameter::Write(
-    QuicDataWriter* writer,
-    ParsedQuicVersion version) const {
+    QuicDataWriter* writer) const {
   DCHECK(IsValid());
   if (value_ == default_value_) {
     // Do not write if the value is default.
     return true;
   }
-  if (!WriteTransportParameterId(writer, param_id_, version)) {
+  if (!writer->WriteVarInt62(param_id_)) {
     QUIC_BUG << "Failed to write param_id for " << *this;
     return false;
   }
   const QuicVariableLengthIntegerLength value_length =
       QuicDataWriter::GetVarInt62Len(value_);
-  if (version.HasVarIntTransportParams()) {
-    if (!writer->WriteVarInt62(value_length)) {
-      QUIC_BUG << "Failed to write value_length for " << *this;
-      return false;
-    }
-  } else {
-    if (!writer->WriteUInt16(value_length)) {
-      QUIC_BUG << "Failed to write value_length16 for " << *this;
-      return false;
-    }
+  if (!writer->WriteVarInt62(value_length)) {
+    QUIC_BUG << "Failed to write value_length for " << *this;
+    return false;
   }
   if (!writer->WriteVarInt62(value_, value_length)) {
     QUIC_BUG << "Failed to write value for " << *this;
@@ -475,9 +383,6 @@
     rv += " " + TransportParameterIdToString(kGoogleUserAgentId) + " \"" +
           user_agent_id.value() + "\"";
   }
-  if (support_handshake_done) {
-    rv += " " + TransportParameterIdToString(kGoogleSupportHandshakeDone);
-  }
   if (key_update_not_yet_supported) {
     rv += " " + TransportParameterIdToString(kGoogleKeyUpdateNotYetSupported);
   }
@@ -529,7 +434,6 @@
                                  kVarInt62MaxValue),
       max_datagram_frame_size(kMaxDatagramFrameSize),
       initial_round_trip_time_us(kInitialRoundTripTime),
-      support_handshake_done(false),
       key_update_not_yet_supported(false)
 // Important note: any new transport parameters must be added
 // to TransportParameters::AreValid, SerializeTransportParameters and
@@ -565,7 +469,6 @@
       initial_round_trip_time_us(other.initial_round_trip_time_us),
       google_connection_options(other.google_connection_options),
       user_agent_id(other.user_agent_id),
-      support_handshake_done(other.support_handshake_done),
       key_update_not_yet_supported(other.key_update_not_yet_supported),
       custom_parameters(other.custom_parameters) {
   if (other.preferred_address) {
@@ -607,7 +510,6 @@
             rhs.initial_round_trip_time_us.value() &&
         google_connection_options == rhs.google_connection_options &&
         user_agent_id == rhs.user_agent_id &&
-        support_handshake_done == rhs.support_handshake_done &&
         key_update_not_yet_supported == rhs.key_update_not_yet_supported &&
         custom_parameters == rhs.custom_parameters)) {
     return false;
@@ -705,7 +607,7 @@
 
 TransportParameters::~TransportParameters() = default;
 
-bool SerializeTransportParameters(ParsedQuicVersion version,
+bool SerializeTransportParameters(ParsedQuicVersion /*version*/,
                                   const TransportParameters& in,
                                   std::vector<uint8_t>* out) {
   std::string error_details;
@@ -763,7 +665,6 @@
       kIntegerParameterLength +           // initial_round_trip_time_us
       kTypeAndValueLength +               // google_connection_options
       kTypeAndValueLength +               // user_agent_id
-      kTypeAndValueLength +               // support_handshake_done
       kTypeAndValueLength +               // key_update_not_yet_supported
       kTypeAndValueLength +               // google-version
       kGreaseParameterLength;             // GREASE
@@ -790,38 +691,23 @@
   out->resize(max_transport_param_length);
   QuicDataWriter writer(out->size(), reinterpret_cast<char*>(out->data()));
 
-  if (!version.HasVarIntTransportParams()) {
-    // Versions that do not use variable integer transport parameters carry
-    // a 16-bit length of the remaining transport parameters. We write 0 here
-    // to reserve 16 bits, and we fill it in at the end of this function.
-    // TODO(b/150465921) add support for doing this in QuicDataWriter.
-    if (!writer.WriteUInt16(0)) {
-      QUIC_BUG << "Failed to write transport parameter fake length prefix for "
-               << in;
-      return false;
-    }
-  }
-
   // original_destination_connection_id
   if (in.original_destination_connection_id.has_value()) {
     DCHECK_EQ(Perspective::IS_SERVER, in.perspective);
     QuicConnectionId original_destination_connection_id =
         in.original_destination_connection_id.value();
-    if (!WriteTransportParameterId(
-            &writer, TransportParameters::kOriginalDestinationConnectionId,
-            version) ||
-        !WriteTransportParameterStringPiece(
-            &writer,
+    if (!writer.WriteVarInt62(
+            TransportParameters::kOriginalDestinationConnectionId) ||
+        !writer.WriteStringPieceVarInt62(
             absl::string_view(original_destination_connection_id.data(),
-                              original_destination_connection_id.length()),
-            version)) {
+                              original_destination_connection_id.length()))) {
       QUIC_BUG << "Failed to write original_destination_connection_id "
                << original_destination_connection_id << " for " << in;
       return false;
     }
   }
 
-  if (!in.max_idle_timeout_ms.Write(&writer, version)) {
+  if (!in.max_idle_timeout_ms.Write(&writer)) {
     QUIC_BUG << "Failed to write idle_timeout for " << in;
     return false;
   }
@@ -830,42 +716,36 @@
   if (!in.stateless_reset_token.empty()) {
     DCHECK_EQ(kStatelessResetTokenLength, in.stateless_reset_token.size());
     DCHECK_EQ(Perspective::IS_SERVER, in.perspective);
-    if (!WriteTransportParameterId(
-            &writer, TransportParameters::kStatelessResetToken, version) ||
-        !WriteTransportParameterStringPiece(
-            &writer,
-            absl::string_view(
-                reinterpret_cast<const char*>(in.stateless_reset_token.data()),
-                in.stateless_reset_token.size()),
-            version)) {
+    if (!writer.WriteVarInt62(TransportParameters::kStatelessResetToken) ||
+        !writer.WriteStringPieceVarInt62(absl::string_view(
+            reinterpret_cast<const char*>(in.stateless_reset_token.data()),
+            in.stateless_reset_token.size()))) {
       QUIC_BUG << "Failed to write stateless_reset_token of length "
                << in.stateless_reset_token.size() << " for " << in;
       return false;
     }
   }
 
-  if (!in.max_udp_payload_size.Write(&writer, version) ||
-      !in.initial_max_data.Write(&writer, version) ||
-      !in.initial_max_stream_data_bidi_local.Write(&writer, version) ||
-      !in.initial_max_stream_data_bidi_remote.Write(&writer, version) ||
-      !in.initial_max_stream_data_uni.Write(&writer, version) ||
-      !in.initial_max_streams_bidi.Write(&writer, version) ||
-      !in.initial_max_streams_uni.Write(&writer, version) ||
-      !in.ack_delay_exponent.Write(&writer, version) ||
-      !in.max_ack_delay.Write(&writer, version) ||
-      !in.min_ack_delay_us.Write(&writer, version) ||
-      !in.active_connection_id_limit.Write(&writer, version) ||
-      !in.max_datagram_frame_size.Write(&writer, version) ||
-      !in.initial_round_trip_time_us.Write(&writer, version)) {
+  if (!in.max_udp_payload_size.Write(&writer) ||
+      !in.initial_max_data.Write(&writer) ||
+      !in.initial_max_stream_data_bidi_local.Write(&writer) ||
+      !in.initial_max_stream_data_bidi_remote.Write(&writer) ||
+      !in.initial_max_stream_data_uni.Write(&writer) ||
+      !in.initial_max_streams_bidi.Write(&writer) ||
+      !in.initial_max_streams_uni.Write(&writer) ||
+      !in.ack_delay_exponent.Write(&writer) ||
+      !in.max_ack_delay.Write(&writer) || !in.min_ack_delay_us.Write(&writer) ||
+      !in.active_connection_id_limit.Write(&writer) ||
+      !in.max_datagram_frame_size.Write(&writer) ||
+      !in.initial_round_trip_time_us.Write(&writer)) {
     QUIC_BUG << "Failed to write integers for " << in;
     return false;
   }
 
   // disable_active_migration
   if (in.disable_active_migration) {
-    if (!WriteTransportParameterId(
-            &writer, TransportParameters::kDisableActiveMigration, version) ||
-        !WriteTransportParameterLength(&writer, /*length=*/0, version)) {
+    if (!writer.WriteVarInt62(TransportParameters::kDisableActiveMigration) ||
+        !writer.WriteVarInt62(/* transport parameter length */ 0)) {
       QUIC_BUG << "Failed to write disable_active_migration for " << in;
       return false;
     }
@@ -889,10 +769,9 @@
         /* connection ID length byte */ sizeof(uint8_t) +
         in.preferred_address->connection_id.length() +
         in.preferred_address->stateless_reset_token.size();
-    if (!WriteTransportParameterId(
-            &writer, TransportParameters::kPreferredAddress, version) ||
-        !WriteTransportParameterLength(&writer, preferred_address_length,
-                                       version) ||
+    if (!writer.WriteVarInt62(TransportParameters::kPreferredAddress) ||
+        !writer.WriteVarInt62(
+            /* transport parameter length */ preferred_address_length) ||
         !writer.WriteStringPiece(v4_address_bytes) ||
         !writer.WriteUInt16(in.preferred_address->ipv4_socket_address.port()) ||
         !writer.WriteStringPiece(v6_address_bytes) ||
@@ -912,14 +791,11 @@
   if (in.initial_source_connection_id.has_value()) {
     QuicConnectionId initial_source_connection_id =
         in.initial_source_connection_id.value();
-    if (!WriteTransportParameterId(
-            &writer, TransportParameters::kInitialSourceConnectionId,
-            version) ||
-        !WriteTransportParameterStringPiece(
-            &writer,
+    if (!writer.WriteVarInt62(
+            TransportParameters::kInitialSourceConnectionId) ||
+        !writer.WriteStringPieceVarInt62(
             absl::string_view(initial_source_connection_id.data(),
-                              initial_source_connection_id.length()),
-            version)) {
+                              initial_source_connection_id.length()))) {
       QUIC_BUG << "Failed to write initial_source_connection_id "
                << initial_source_connection_id << " for " << in;
       return false;
@@ -931,13 +807,10 @@
     DCHECK_EQ(Perspective::IS_SERVER, in.perspective);
     QuicConnectionId retry_source_connection_id =
         in.retry_source_connection_id.value();
-    if (!WriteTransportParameterId(
-            &writer, TransportParameters::kRetrySourceConnectionId, version) ||
-        !WriteTransportParameterStringPiece(
-            &writer,
+    if (!writer.WriteVarInt62(TransportParameters::kRetrySourceConnectionId) ||
+        !writer.WriteStringPieceVarInt62(
             absl::string_view(retry_source_connection_id.data(),
-                              retry_source_connection_id.length()),
-            version)) {
+                              retry_source_connection_id.length()))) {
       QUIC_BUG << "Failed to write retry_source_connection_id "
                << retry_source_connection_id << " for " << in;
       return false;
@@ -950,10 +823,9 @@
                   "bad size");
     uint64_t connection_options_length =
         in.google_connection_options.value().size() * 4;
-    if (!WriteTransportParameterId(
-            &writer, TransportParameters::kGoogleConnectionOptions, version) ||
-        !WriteTransportParameterLength(&writer, connection_options_length,
-                                       version)) {
+    if (!writer.WriteVarInt62(TransportParameters::kGoogleConnectionOptions) ||
+        !writer.WriteVarInt62(
+            /* transport parameter length */ connection_options_length)) {
       QUIC_BUG << "Failed to write google_connection_options of length "
                << connection_options_length << " for " << in;
       return false;
@@ -970,33 +842,19 @@
 
   // Google-specific user agent identifier.
   if (in.user_agent_id.has_value()) {
-    if (!WriteTransportParameterId(
-            &writer, TransportParameters::kGoogleUserAgentId, version) ||
-        !WriteTransportParameterStringPiece(&writer, in.user_agent_id.value(),
-                                            version)) {
+    if (!writer.WriteVarInt62(TransportParameters::kGoogleUserAgentId) ||
+        !writer.WriteStringPieceVarInt62(in.user_agent_id.value())) {
       QUIC_BUG << "Failed to write Google user agent ID \""
                << in.user_agent_id.value() << "\" for " << in;
       return false;
     }
   }
 
-  // Google-specific support handshake done.
-  if (in.support_handshake_done) {
-    if (!WriteTransportParameterId(
-            &writer, TransportParameters::kGoogleSupportHandshakeDone,
-            version) ||
-        !WriteTransportParameterLength(&writer, /*length=*/0, version)) {
-      QUIC_BUG << "Failed to write support_handshake_done for " << in;
-      return false;
-    }
-  }
-
   // Google-specific indicator for key update not yet supported.
   if (in.key_update_not_yet_supported) {
-    if (!WriteTransportParameterId(
-            &writer, TransportParameters::kGoogleKeyUpdateNotYetSupported,
-            version) ||
-        !WriteTransportParameterLength(&writer, /*length=*/0, version)) {
+    if (!writer.WriteVarInt62(
+            TransportParameters::kGoogleKeyUpdateNotYetSupported) ||
+        !writer.WriteVarInt62(/* transport parameter length */ 0)) {
       QUIC_BUG << "Failed to write key_update_not_yet_supported for " << in;
       return false;
     }
@@ -1010,9 +868,9 @@
         /* versions length */ sizeof(uint8_t) +
         sizeof(QuicVersionLabel) * in.supported_versions.size();
   }
-  if (!WriteTransportParameterId(
-          &writer, TransportParameters::kGoogleQuicVersion, version) ||
-      !WriteTransportParameterLength(&writer, google_version_length, version) ||
+  if (!writer.WriteVarInt62(TransportParameters::kGoogleQuicVersion) ||
+      !writer.WriteVarInt62(
+          /* transport parameter length */ google_version_length) ||
       !writer.WriteUInt32(in.version)) {
     QUIC_BUG << "Failed to write Google version extension for " << in;
     return false;
@@ -1040,8 +898,8 @@
                << " is not allowed";
       return false;
     }
-    if (!WriteTransportParameterId(&writer, param_id, version) ||
-        !WriteTransportParameterStringPiece(&writer, kv.second, version)) {
+    if (!writer.WriteVarInt62(param_id) ||
+        !writer.WriteStringPieceVarInt62(kv.second)) {
       QUIC_BUG << "Failed to write custom parameter " << param_id;
       return false;
     }
@@ -1053,55 +911,28 @@
     // https://quicwg.org/base-drafts/draft-ietf-quic-transport.html
     // This forces receivers to support unexpected input.
     QuicRandom* random = QuicRandom::GetInstance();
-    uint64_t grease_id64 = random->RandUint64();
-    if (version.HasVarIntTransportParams()) {
-      // With these versions, identifiers are 62 bits long so we need to ensure
-      // that the output of the computation below fits in 62 bits.
-      grease_id64 %= ((1ULL << 62) - 31);
-    } else {
-      // Same with 16 bits.
-      grease_id64 %= ((1ULL << 16) - 31);
-    }
+    // Transport parameter identifiers are 62 bits long so we need to ensure
+    // that the output of the computation below fits in 62 bits.
+    uint64_t grease_id64 = random->RandUint64() % ((1ULL << 62) - 31);
     // Make sure grease_id % 31 == 27. Note that this is not uniformely
     // distributed but is acceptable since no security depends on this
     // randomness.
     grease_id64 = (grease_id64 / 31) * 31 + 27;
-    DCHECK(version.HasVarIntTransportParams() ||
-           grease_id64 <= std::numeric_limits<uint16_t>::max())
-        << grease_id64 << " invalid for " << version;
     TransportParameters::TransportParameterId grease_id =
         static_cast<TransportParameters::TransportParameterId>(grease_id64);
     const size_t grease_length = random->RandUint64() % kMaxGreaseLength;
     DCHECK_GE(kMaxGreaseLength, grease_length);
     char grease_contents[kMaxGreaseLength];
     random->RandBytes(grease_contents, grease_length);
-    if (!WriteTransportParameterId(&writer, grease_id, version) ||
-        !WriteTransportParameterStringPiece(
-            &writer, absl::string_view(grease_contents, grease_length),
-            version)) {
+    if (!writer.WriteVarInt62(grease_id) ||
+        !writer.WriteStringPieceVarInt62(
+            absl::string_view(grease_contents, grease_length))) {
       QUIC_BUG << "Failed to write GREASE parameter "
                << TransportParameterIdToString(grease_id);
       return false;
     }
   }
 
-  if (!version.HasVarIntTransportParams()) {
-    // Fill in the length prefix at the start of the transport parameters.
-    if (writer.length() < sizeof(uint16_t) ||
-        writer.length() - sizeof(uint16_t) >
-            std::numeric_limits<uint16_t>::max()) {
-      QUIC_BUG << "Cannot write length " << writer.length() << " for " << in;
-      return false;
-    }
-    const uint16_t length_prefix = writer.length() - sizeof(uint16_t);
-    QuicDataWriter length_prefix_writer(out->size(),
-                                        reinterpret_cast<char*>(out->data()));
-    if (!length_prefix_writer.WriteUInt16(length_prefix)) {
-      QUIC_BUG << "Failed to write length prefix for " << in;
-      return false;
-    }
-  }
-
   out->resize(writer.length());
 
   QUIC_DLOG(INFO) << "Serialized " << in << " as " << writer.length()
@@ -1119,28 +950,16 @@
   out->perspective = perspective;
   QuicDataReader reader(reinterpret_cast<const char*>(in), in_len);
 
-  if (!version.HasVarIntTransportParams()) {
-    uint16_t full_length;
-    if (!reader.ReadUInt16(&full_length)) {
-      *error_details = "Failed to parse the transport parameter full length";
-      return false;
-    }
-    if (full_length != reader.BytesRemaining()) {
-      *error_details =
-          absl::StrCat("Invalid transport parameter full length ", full_length,
-                       " != ", reader.BytesRemaining());
-      return false;
-    }
-  }
-
   while (!reader.IsDoneReading()) {
-    TransportParameters::TransportParameterId param_id;
-    if (!ReadTransportParameterId(&reader, version, &param_id)) {
+    uint64_t param_id64;
+    if (!reader.ReadVarInt62(&param_id64)) {
       *error_details = "Failed to parse transport parameter ID";
       return false;
     }
+    TransportParameters::TransportParameterId param_id =
+        static_cast<TransportParameters::TransportParameterId>(param_id64);
     absl::string_view value;
-    if (!ReadTransportParameterLengthAndValue(&reader, version, &value)) {
+    if (!reader.ReadStringPieceVarInt62(&value)) {
       *error_details =
           "Failed to read length and value of transport parameter " +
           TransportParameterIdToString(param_id);
@@ -1349,13 +1168,6 @@
         }
         out->user_agent_id = std::string(value_reader.ReadRemainingPayload());
         break;
-      case TransportParameters::kGoogleSupportHandshakeDone:
-        if (out->support_handshake_done) {
-          *error_details = "Received a second support_handshake_done";
-          return false;
-        }
-        out->support_handshake_done = true;
-        break;
       case TransportParameters::kGoogleKeyUpdateNotYetSupported:
         if (out->key_update_not_yet_supported) {
           *error_details = "Received a second key_update_not_yet_supported";
diff --git a/quic/core/crypto/transport_parameters.h b/quic/core/crypto/transport_parameters.h
index 8c7970c..97f51af 100644
--- a/quic/core/crypto/transport_parameters.h
+++ b/quic/core/crypto/transport_parameters.h
@@ -24,7 +24,7 @@
 // TransportParameters contains parameters for QUIC's transport layer that are
 // exchanged during the TLS handshake. This struct is a mirror of the struct in
 // the "Transport Parameter Encoding" section of draft-ietf-quic-transport.
-// This struct currently uses the values from draft 20.
+// This struct currently uses the values from draft 29.
 struct QUIC_EXPORT_PRIVATE TransportParameters {
   // The identifier used to differentiate transport parameters.
   enum TransportParameterId : uint64_t;
@@ -47,7 +47,7 @@
     // Writes to a crypto byte buffer, used during serialization. Does not write
     // anything if the value is equal to the parameter's default value.
     // Returns whether the write was successful.
-    bool Write(QuicDataWriter* writer, ParsedQuicVersion version) const;
+    bool Write(QuicDataWriter* writer) const;
     // Reads from a crypto byte string, used during parsing.
     // Returns whether the read was successful.
     // On failure, this method will write a human-readable error message to
@@ -207,9 +207,6 @@
   // Google-specific user agent identifier.
   absl::optional<std::string> user_agent_id;
 
-  // Google-specific handshake done support. This is only used for T050.
-  bool support_handshake_done;
-
   // Google-specific mechanism to indicate that IETF QUIC Key Update has not
   // yet been implemented. This will be removed once we implement it.
   bool key_update_not_yet_supported;
diff --git a/quic/core/crypto/transport_parameters_test.cc b/quic/core/crypto/transport_parameters_test.cc
index ab8360e..e789961 100644
--- a/quic/core/crypto/transport_parameters_test.cc
+++ b/quic/core/crypto/transport_parameters_test.cc
@@ -37,7 +37,6 @@
 const uint8_t kFakePreferredStatelessResetTokenData[16] = {
     0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
     0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F};
-const bool kFakeSupportHandshakeDone = true;
 const bool kFakeKeyUpdateNotYetSupported = true;
 
 const auto kCustomParameter1 =
@@ -250,7 +249,6 @@
   orig_params.initial_round_trip_time_us.set_value(kFakeInitialRoundTripTime);
   orig_params.google_connection_options = CreateFakeGoogleConnectionOptions();
   orig_params.user_agent_id = CreateFakeUserAgentId();
-  orig_params.support_handshake_done = kFakeSupportHandshakeDone;
   orig_params.key_update_not_yet_supported = kFakeKeyUpdateNotYetSupported;
   orig_params.custom_parameters[kCustomParameter1] = kCustomParameter1Value;
   orig_params.custom_parameters[kCustomParameter2] = kCustomParameter2Value;
@@ -285,7 +283,6 @@
   orig_params.initial_round_trip_time_us.set_value(kFakeInitialRoundTripTime);
   orig_params.google_connection_options = CreateFakeGoogleConnectionOptions();
   orig_params.user_agent_id = CreateFakeUserAgentId();
-  orig_params.support_handshake_done = kFakeSupportHandshakeDone;
   orig_params.key_update_not_yet_supported = kFakeKeyUpdateNotYetSupported;
   orig_params.custom_parameters[kCustomParameter1] = kCustomParameter1Value;
   orig_params.custom_parameters[kCustomParameter2] = kCustomParameter2Value;
@@ -461,88 +458,6 @@
 
 TEST_P(TransportParametersTest, ParseClientParams) {
   // clang-format off
-  const uint8_t kClientParamsOld[] = {
-      0x00, 0x84,              // length of the parameters array that follows
-      // max_idle_timeout
-      0x00, 0x01,  // parameter id
-      0x00, 0x02,  // length
-      0x6e, 0xec,  // value
-      // max_udp_payload_size
-      0x00, 0x03,  // parameter id
-      0x00, 0x02,  // length
-      0x63, 0x29,  // value
-      // initial_max_data
-      0x00, 0x04,  // parameter id
-      0x00, 0x02,  // length
-      0x40, 0x65,  // value
-      // initial_max_stream_data_bidi_local
-      0x00, 0x05,  // parameter id
-      0x00, 0x02,  // length
-      0x47, 0xD1,  // value
-      // initial_max_stream_data_bidi_remote
-      0x00, 0x06,  // parameter id
-      0x00, 0x02,  // length
-      0x47, 0xD2,  // value
-      // initial_max_stream_data_uni
-      0x00, 0x07,  // parameter id
-      0x00, 0x02,  // length
-      0x4B, 0xB8,  // value
-      // initial_max_streams_bidi
-      0x00, 0x08,  // parameter id
-      0x00, 0x01,  // length
-      0x15,  // value
-      // initial_max_streams_uni
-      0x00, 0x09,  // parameter id
-      0x00, 0x01,  // length
-      0x16,  // value
-      // ack_delay_exponent
-      0x00, 0x0a,  // parameter id
-      0x00, 0x01,  // length
-      0x0a,  // value
-      // max_ack_delay
-      0x00, 0x0b,  // parameter id
-      0x00, 0x01,  // length
-      0x33,  // value
-      // min_ack_delay_us
-      0xde, 0x1a,  // parameter id
-      0x00, 0x02,  // length
-      0x43, 0xe8,  // value
-      // disable_active_migration
-      0x00, 0x0c,  // parameter id
-      0x00, 0x00,  // length
-      // active_connection_id_limit
-      0x00, 0x0e,  // parameter id
-      0x00, 0x01,  // length
-      0x34,  // value
-      // initial_source_connection_id
-      0x00, 0x0f,  // parameter id
-      0x00, 0x08,  // length
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x45,
-      // initial_round_trip_time_us
-      0x31, 0x27,  // parameter id
-      0x00, 0x01,  // length
-      0x35,  // value
-      // google_connection_options
-      0x31, 0x28,  // parameter id
-      0x00, 0x0c,  // length
-      'A', 'L', 'P', 'N',  // value
-      'E', 'F', 'G', 0x00,
-      'H', 'I', 'J', 0xff,
-      // user_agent_id
-      0x31, 0x29,  // parameter id
-      0x00, 0x08,  // length
-      'F', 'a', 'k', 'e', 'U', 'A', 'I', 'D',  // value
-      // support_handshake_done
-      0x31, 0x2A,  // parameter id
-      0x00, 0x00,  // value
-      // key_update_not_yet_supported
-      0x31, 0x2B,  // parameter id
-      0x00, 0x00,  // value
-      // Google version extension
-      0x47, 0x52,  // parameter id
-      0x00, 0x04,  // length
-      0x01, 0x23, 0x45, 0x67,  // initial version
-  };
   const uint8_t kClientParams[] = {
       // max_idle_timeout
       0x01,  // parameter id
@@ -613,9 +528,6 @@
       0x71, 0x29,  // parameter id
       0x08,  // length
       'F', 'a', 'k', 'e', 'U', 'A', 'I', 'D',  // value
-      // support_handshake_done
-      0x71, 0x2A,  // parameter id
-      0x00,  // length
       // key_update_not_yet_supported
       0x71, 0x2B,  // parameter id
       0x00,  // length
@@ -628,10 +540,6 @@
   const uint8_t* client_params =
       reinterpret_cast<const uint8_t*>(kClientParams);
   size_t client_params_length = ABSL_ARRAYSIZE(kClientParams);
-  if (!version_.HasVarIntTransportParams()) {
-    client_params = reinterpret_cast<const uint8_t*>(kClientParamsOld);
-    client_params_length = ABSL_ARRAYSIZE(kClientParamsOld);
-  }
   TransportParameters new_params;
   std::string error_details;
   ASSERT_TRUE(ParseTransportParameters(version_, Perspective::IS_CLIENT,
@@ -675,33 +583,12 @@
             new_params.google_connection_options.value());
   ASSERT_TRUE(new_params.user_agent_id.has_value());
   EXPECT_EQ(CreateFakeUserAgentId(), new_params.user_agent_id.value());
-  EXPECT_TRUE(new_params.support_handshake_done);
   EXPECT_TRUE(new_params.key_update_not_yet_supported);
 }
 
 TEST_P(TransportParametersTest,
        ParseClientParamsFailsWithFullStatelessResetToken) {
   // clang-format off
-  const uint8_t kClientParamsWithFullTokenOld[] = {
-      0x00, 0x26,  // length parameters array that follows
-      // max_idle_timeout
-      0x00, 0x01,  // parameter id
-      0x00, 0x02,  // length
-      0x6e, 0xec,  // value
-      // stateless_reset_token
-      0x00, 0x02,  // parameter id
-      0x00, 0x10,  // length
-      0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
-      0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
-      // max_udp_payload_size
-      0x00, 0x03,  // parameter id
-      0x00, 0x02,  // length
-      0x63, 0x29,  // value
-      // initial_max_data
-      0x00, 0x04,  // parameter id
-      0x00, 0x02,  // length
-      0x40, 0x65,  // value
-  };
   const uint8_t kClientParamsWithFullToken[] = {
       // max_idle_timeout
       0x01,  // parameter id
@@ -725,11 +612,6 @@
   const uint8_t* client_params =
       reinterpret_cast<const uint8_t*>(kClientParamsWithFullToken);
   size_t client_params_length = ABSL_ARRAYSIZE(kClientParamsWithFullToken);
-  if (!version_.HasVarIntTransportParams()) {
-    client_params =
-        reinterpret_cast<const uint8_t*>(kClientParamsWithFullTokenOld);
-    client_params_length = ABSL_ARRAYSIZE(kClientParamsWithFullTokenOld);
-  }
   TransportParameters out_params;
   std::string error_details;
   EXPECT_FALSE(ParseTransportParameters(version_, Perspective::IS_CLIENT,
@@ -741,24 +623,6 @@
 TEST_P(TransportParametersTest,
        ParseClientParamsFailsWithEmptyStatelessResetToken) {
   // clang-format off
-  const uint8_t kClientParamsWithEmptyTokenOld[] = {
-      0x00, 0x16,  // length parameters array that follows
-      // max_idle_timeout
-      0x00, 0x01,  // parameter id
-      0x00, 0x02,  // length
-      0x6e, 0xec,  // value
-      // stateless_reset_token
-      0x00, 0x02,  // parameter id
-      0x00, 0x00,
-      // max_udp_payload_size
-      0x00, 0x03,  // parameter id
-      0x00, 0x02,  // length
-      0x63, 0x29,  // value
-      // initial_max_data
-      0x00, 0x04,  // parameter id
-      0x00, 0x02,  // length
-      0x40, 0x65,  // value
-  };
   const uint8_t kClientParamsWithEmptyToken[] = {
       // max_idle_timeout
       0x01,  // parameter id
@@ -780,11 +644,6 @@
   const uint8_t* client_params =
       reinterpret_cast<const uint8_t*>(kClientParamsWithEmptyToken);
   size_t client_params_length = ABSL_ARRAYSIZE(kClientParamsWithEmptyToken);
-  if (!version_.HasVarIntTransportParams()) {
-    client_params =
-        reinterpret_cast<const uint8_t*>(kClientParamsWithEmptyTokenOld);
-    client_params_length = ABSL_ARRAYSIZE(kClientParamsWithEmptyTokenOld);
-  }
   TransportParameters out_params;
   std::string error_details;
   EXPECT_FALSE(ParseTransportParameters(version_, Perspective::IS_CLIENT,
@@ -796,21 +655,6 @@
 
 TEST_P(TransportParametersTest, ParseClientParametersRepeated) {
   // clang-format off
-  const uint8_t kClientParamsRepeatedOld[] = {
-      0x00, 0x12,  // length parameters array that follows
-      // max_idle_timeout
-      0x00, 0x01,  // parameter id
-      0x00, 0x02,  // length
-      0x6e, 0xec,  // value
-      // max_udp_payload_size
-      0x00, 0x03,  // parameter id
-      0x00, 0x02,  // length
-      0x63, 0x29,  // value
-      // max_idle_timeout (repeated)
-      0x00, 0x01,  // parameter id
-      0x00, 0x02,  // length
-      0x6e, 0xec,  // value
-  };
   const uint8_t kClientParamsRepeated[] = {
       // max_idle_timeout
       0x01,  // parameter id
@@ -829,10 +673,6 @@
   const uint8_t* client_params =
       reinterpret_cast<const uint8_t*>(kClientParamsRepeated);
   size_t client_params_length = ABSL_ARRAYSIZE(kClientParamsRepeated);
-  if (!version_.HasVarIntTransportParams()) {
-    client_params = reinterpret_cast<const uint8_t*>(kClientParamsRepeatedOld);
-    client_params_length = ABSL_ARRAYSIZE(kClientParamsRepeatedOld);
-  }
   TransportParameters out_params;
   std::string error_details;
   EXPECT_FALSE(ParseTransportParameters(version_, Perspective::IS_CLIENT,
@@ -843,108 +683,6 @@
 
 TEST_P(TransportParametersTest, ParseServerParams) {
   // clang-format off
-  const uint8_t kServerParamsOld[] = {
-      0x00, 0xdd,  // length of parameters array that follows
-      // original_destination_connection_id
-      0x00, 0x00,  // parameter id
-      0x00, 0x08,  // length
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x37,
-      // max_idle_timeout
-      0x00, 0x01,  // parameter id
-      0x00, 0x02,  // length
-      0x6e, 0xec,  // value
-      // stateless_reset_token
-      0x00, 0x02,  // parameter id
-      0x00, 0x10,  // length
-      0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
-      0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
-      // max_udp_payload_size
-      0x00, 0x03,  // parameter id
-      0x00, 0x02,  // length
-      0x63, 0x29,  // value
-      // initial_max_data
-      0x00, 0x04,  // parameter id
-      0x00, 0x02,  // length
-      0x40, 0x65,  // value
-      // initial_max_stream_data_bidi_local
-      0x00, 0x05,  // parameter id
-      0x00, 0x02,  // length
-      0x47, 0xD1,  // value
-      // initial_max_stream_data_bidi_remote
-      0x00, 0x06,  // parameter id
-      0x00, 0x02,  // length
-      0x47, 0xD2,  // value
-      // initial_max_stream_data_uni
-      0x00, 0x07,  // parameter id
-      0x00, 0x02,  // length
-      0x4B, 0xB8,  // value
-      // initial_max_streams_bidi
-      0x00, 0x08,  // parameter id
-      0x00, 0x01,  // length
-      0x15,  // value
-      // initial_max_streams_uni
-      0x00, 0x09,  // parameter id
-      0x00, 0x01,  // length
-      0x16,  // value
-      // ack_delay_exponent
-      0x00, 0x0a,  // parameter id
-      0x00, 0x01,  // length
-      0x0a,  // value
-      // max_ack_delay
-      0x00, 0x0b,  // parameter id
-      0x00, 0x01,  // length
-      0x33,  // value
-      // min_ack_delay_us
-      0xde, 0x1a,  // parameter id
-      0x00, 0x02,  // length
-      0x43, 0xe8,  // value
-      // disable_active_migration
-      0x00, 0x0c,  // parameter id
-      0x00, 0x00,  // length
-      // preferred_address
-      0x00, 0x0d,  // parameter id
-      0x00, 0x31,  // length
-      0x41, 0x42, 0x43, 0x44,  // IPv4 address
-      0x48, 0x84,  // IPv4 port
-      0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,  // IPv6 address
-      0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
-      0x63, 0x36,  // IPv6 port
-      0x08,        // connection ID length
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xBE, 0xEF,  // connection ID
-      0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,  // stateless reset token
-      0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
-      // active_connection_id_limit
-      0x00, 0x0e,  // parameter id
-      0x00, 0x01,  // length
-      0x34,  // value
-      // initial_source_connection_id
-      0x00, 0x0f,  // parameter id
-      0x00, 0x08,  // length
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x45,
-      // retry_source_connection_id
-      0x00, 0x10,  // parameter id
-      0x00, 0x08,  // length
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x98, 0x76,
-      // google_connection_options
-      0x31, 0x28,  // parameter id
-      0x00, 0x0c,  // length
-      'A', 'L', 'P', 'N',  // value
-      'E', 'F', 'G', 0x00,
-      'H', 'I', 'J', 0xff,
-      // support_handshake_done
-      0x31, 0x2A,  // parameter id
-      0x00, 0x00,  // value
-      // key_update_not_yet_supported
-      0x31, 0x2B,  // parameter id
-      0x00, 0x00,  // value
-      // Google version extension
-      0x47, 0x52,  // parameter id
-      0x00, 0x0d,  // length
-      0x01, 0x23, 0x45, 0x67,  // negotiated_version
-      0x08,  // length of supported versions array
-      0x01, 0x23, 0x45, 0x67,
-      0x89, 0xab, 0xcd, 0xef,
-  };
   const uint8_t kServerParams[] = {
       // original_destination_connection_id
       0x00,  // parameter id
@@ -1032,9 +770,6 @@
       'A', 'L', 'P', 'N',  // value
       'E', 'F', 'G', 0x00,
       'H', 'I', 'J', 0xff,
-      // support_handshake_done
-      0x71, 0x2A,  // parameter id
-      0x00,  // length
       // key_update_not_yet_supported
       0x71, 0x2B,  // parameter id
       0x00,  // length
@@ -1050,10 +785,6 @@
   const uint8_t* server_params =
       reinterpret_cast<const uint8_t*>(kServerParams);
   size_t server_params_length = ABSL_ARRAYSIZE(kServerParams);
-  if (!version_.HasVarIntTransportParams()) {
-    server_params = reinterpret_cast<const uint8_t*>(kServerParamsOld);
-    server_params_length = ABSL_ARRAYSIZE(kServerParamsOld);
-  }
   TransportParameters new_params;
   std::string error_details;
   ASSERT_TRUE(ParseTransportParameters(version_, Perspective::IS_SERVER,
@@ -1110,32 +841,11 @@
   EXPECT_EQ(CreateFakeGoogleConnectionOptions(),
             new_params.google_connection_options.value());
   EXPECT_FALSE(new_params.user_agent_id.has_value());
-  EXPECT_TRUE(new_params.support_handshake_done);
   EXPECT_TRUE(new_params.key_update_not_yet_supported);
 }
 
 TEST_P(TransportParametersTest, ParseServerParametersRepeated) {
   // clang-format off
-  const uint8_t kServerParamsRepeatedOld[] = {
-      0x00, 0x2c,  // length of parameters array that follows
-      // original_destination_connection_id
-      0x00, 0x00,  // parameter id
-      0x00, 0x08,  // length
-      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x37,
-      // max_idle_timeout
-      0x00, 0x01,  // parameter id
-      0x00, 0x02,  // length
-      0x6e, 0xec,  // value
-      // stateless_reset_token
-      0x00, 0x02,  // parameter id
-      0x00, 0x10,  // length
-      0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-      0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
-      // max_idle_timeout (repeated)
-      0x00, 0x01,  // parameter id
-      0x00, 0x02,  // length
-      0x6e, 0xec,  // value
-  };
   const uint8_t kServerParamsRepeated[] = {
       // original_destination_connection_id
       0x00,  // parameter id
@@ -1159,10 +869,6 @@
   const uint8_t* server_params =
       reinterpret_cast<const uint8_t*>(kServerParamsRepeated);
   size_t server_params_length = ABSL_ARRAYSIZE(kServerParamsRepeated);
-  if (!version_.HasVarIntTransportParams()) {
-    server_params = reinterpret_cast<const uint8_t*>(kServerParamsRepeatedOld);
-    server_params_length = ABSL_ARRAYSIZE(kServerParamsRepeatedOld);
-  }
   TransportParameters out_params;
   std::string error_details;
   EXPECT_FALSE(ParseTransportParameters(version_, Perspective::IS_SERVER,
@@ -1174,21 +880,6 @@
 TEST_P(TransportParametersTest,
        ParseServerParametersEmptyOriginalConnectionId) {
   // clang-format off
-  const uint8_t kServerParamsEmptyOriginalConnectionIdOld[] = {
-      0x00, 0x1e,  // length of parameters array that follows
-      // original_destination_connection_id
-      0x00, 0x00,  // parameter id
-      0x00, 0x00,  // length
-      // max_idle_timeout
-      0x00, 0x01,  // parameter id
-      0x00, 0x02,  // length
-      0x6e, 0xec,  // value
-      // stateless_reset_token
-      0x00, 0x02,  // parameter id
-      0x00, 0x10,  // length
-      0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-      0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
-  };
   const uint8_t kServerParamsEmptyOriginalConnectionId[] = {
       // original_destination_connection_id
       0x00,  // parameter id
@@ -1208,12 +899,6 @@
       reinterpret_cast<const uint8_t*>(kServerParamsEmptyOriginalConnectionId);
   size_t server_params_length =
       ABSL_ARRAYSIZE(kServerParamsEmptyOriginalConnectionId);
-  if (!version_.HasVarIntTransportParams()) {
-    server_params = reinterpret_cast<const uint8_t*>(
-        kServerParamsEmptyOriginalConnectionIdOld);
-    server_params_length =
-        ABSL_ARRAYSIZE(kServerParamsEmptyOriginalConnectionIdOld);
-  }
   TransportParameters out_params;
   std::string error_details;
   ASSERT_TRUE(ParseTransportParameters(version_, Perspective::IS_SERVER,
@@ -1227,12 +912,7 @@
 
 TEST_P(TransportParametersTest, VeryLongCustomParameter) {
   // Ensure we can handle a 70KB custom parameter on both send and receive.
-  size_t custom_value_length = 70000;
-  if (!version_.HasVarIntTransportParams()) {
-    // These versions encode lengths as uint16 so they cannot send as much.
-    custom_value_length = 65000;
-  }
-  std::string custom_value(custom_value_length, '?');
+  std::string custom_value(70000, '?');
   TransportParameters orig_params;
   orig_params.perspective = Perspective::IS_CLIENT;
   orig_params.version = kFakeVersionLabel;
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 4eb0997..91f0a58 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -101,7 +101,7 @@
         kInitialStreamFlowControlWindowForTest);
     session()->config()->SetInitialSessionFlowControlWindowToSend(
         kInitialSessionFlowControlWindowForTest);
-    if (session()->version().AuthenticatesHandshakeConnectionIds()) {
+    if (session()->version().UsesTls()) {
       if (session()->perspective() == Perspective::IS_CLIENT) {
         session()->config()->SetOriginalConnectionIdToSend(
             session()->connection()->connection_id());
@@ -111,9 +111,6 @@
         session()->config()->SetInitialSourceConnectionIdToSend(
             session()->connection()->client_connection_id());
       }
-    }
-    if (session()->connection()->version().handshake_protocol ==
-        PROTOCOL_TLS1_3) {
       TransportParameters transport_parameters;
       EXPECT_TRUE(
           session()->config()->FillTransportParameters(&transport_parameters));
@@ -500,9 +497,9 @@
       EXPECT_CALL(*writer_, WritePacket(_, _, _, _, _))
           .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
     }
-    // HANDSHAKE_DONE frame sent by the server.
-    if (connection_->version().HasHandshakeDone() &&
+    if (connection_->version().UsesTls() &&
         connection_->perspective() == Perspective::IS_SERVER) {
+      // HANDSHAKE_DONE frame.
       EXPECT_CALL(*connection_, SendControlFrame(_))
           .WillOnce(Invoke(&ClearControlFrame));
     }
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index ce107fd..f2771fd 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -80,7 +80,7 @@
         kInitialStreamFlowControlWindowForTest);
     session()->config()->SetInitialSessionFlowControlWindowToSend(
         kInitialSessionFlowControlWindowForTest);
-    if (session()->version().AuthenticatesHandshakeConnectionIds()) {
+    if (session()->version().UsesTls()) {
       if (session()->perspective() == Perspective::IS_CLIENT) {
         session()->config()->SetOriginalConnectionIdToSend(
             session()->connection()->connection_id());
@@ -90,8 +90,6 @@
         session()->config()->SetInitialSourceConnectionIdToSend(
             session()->connection()->client_connection_id());
       }
-    }
-    if (session()->version().UsesTls()) {
       TransportParameters transport_parameters;
       EXPECT_TRUE(
           session()->config()->FillTransportParameters(&transport_parameters));
@@ -113,7 +111,8 @@
     } else {
       session()->SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
     }
-    if (session()->version().HasHandshakeDone()) {
+    if (session()->version().UsesTls()) {
+      // HANDSHAKE_DONE frame.
       EXPECT_CALL(*this, HasPendingRetransmission());
     }
     session()->DiscardOldEncryptionKey(ENCRYPTION_INITIAL);
@@ -389,8 +388,9 @@
     TestCryptoStream* crypto_stream = session_->GetMutableCryptoStream();
     EXPECT_CALL(*crypto_stream, HasPendingRetransmission()).Times(AnyNumber());
 
-    if (connection_->version().HasHandshakeDone() &&
+    if (connection_->version().UsesTls() &&
         session_->perspective() == Perspective::IS_SERVER) {
+      // HANDSHAKE_DONE frame.
       EXPECT_CALL(*connection_, SendControlFrame(_))
           .WillOnce(Invoke(&ClearControlFrame));
     }
diff --git a/quic/core/quic_config.cc b/quic/core/quic_config.cc
index 55f356b..ffade96 100644
--- a/quic/core/quic_config.cc
+++ b/quic/core/quic_config.cc
@@ -447,7 +447,6 @@
       initial_stream_flow_control_window_bytes_(kSFCW, PRESENCE_OPTIONAL),
       initial_session_flow_control_window_bytes_(kCFCW, PRESENCE_OPTIONAL),
       connection_migration_disabled_(kNCMR, PRESENCE_OPTIONAL),
-      support_handshake_done_(0, PRESENCE_OPTIONAL),
       key_update_supported_remotely_(false),
       key_update_supported_locally_(false),
       alternate_server_address_ipv6_(kASAD, PRESENCE_OPTIONAL),
@@ -852,19 +851,6 @@
   return connection_migration_disabled_.HasReceivedValue();
 }
 
-void QuicConfig::SetSupportHandshakeDone() {
-  support_handshake_done_.SetSendValue(1);
-}
-
-bool QuicConfig::HandshakeDoneSupported() const {
-  return support_handshake_done_.HasSendValue() &&
-         support_handshake_done_.GetSendValue() > 0;
-}
-
-bool QuicConfig::PeerSupportsHandshakeDone() const {
-  return support_handshake_done_.HasReceivedValue();
-}
-
 void QuicConfig::SetKeyUpdateSupportedLocally() {
   key_update_supported_locally_ = true;
 }
@@ -1204,7 +1190,6 @@
   params->disable_active_migration =
       connection_migration_disabled_.HasSendValue() &&
       connection_migration_disabled_.GetSendValue() != 0;
-  params->support_handshake_done = HandshakeDoneSupported();
 
   if (alternate_server_address_ipv6_.HasSendValue() ||
       alternate_server_address_ipv4_.HasSendValue()) {
@@ -1350,9 +1335,6 @@
   if (params.disable_active_migration) {
     connection_migration_disabled_.SetReceivedValue(1u);
   }
-  if (params.support_handshake_done) {
-    support_handshake_done_.SetReceivedValue(1u);
-  }
   if (!is_resumption && !params.key_update_not_yet_supported) {
     key_update_supported_remotely_ = true;
   }
diff --git a/quic/core/quic_config.h b/quic/core/quic_config.h
index 6e9eee1..458a4d0 100644
--- a/quic/core/quic_config.h
+++ b/quic/core/quic_config.h
@@ -382,11 +382,6 @@
   void SetDisableConnectionMigration();
   bool DisableConnectionMigration() const;
 
-  // Support handshake done.
-  void SetSupportHandshakeDone();
-  bool HandshakeDoneSupported() const;
-  bool PeerSupportsHandshakeDone() const;
-
   // Key update support.
   void SetKeyUpdateSupportedLocally();
   bool KeyUpdateSupportedForConnection() const;
@@ -582,10 +577,6 @@
   // Uses the disable_active_migration transport parameter in IETF QUIC.
   QuicFixedUint32 connection_migration_disabled_;
 
-  // Whether handshake done is supported. Only used in T050.
-  // Uses the support_handshake_done transport parameter in IETF QUIC.
-  QuicFixedUint32 support_handshake_done_;
-
   // Whether key update is supported by the peer. Uses key_update_not_yet
   // supported transport parameter in IETF QUIC.
   bool key_update_supported_remotely_;
diff --git a/quic/core/quic_config_test.cc b/quic/core/quic_config_test.cc
index 144f495..036326b 100644
--- a/quic/core/quic_config_test.cc
+++ b/quic/core/quic_config_test.cc
@@ -569,7 +569,6 @@
             config_.ReceivedMaxBidirectionalStreams());
 
   EXPECT_FALSE(config_.DisableConnectionMigration());
-  EXPECT_FALSE(config_.PeerSupportsHandshakeDone());
 
   // The following config shouldn't be processed because of resumption.
   EXPECT_FALSE(config_.HasReceivedStatelessResetToken());
@@ -594,7 +593,6 @@
   params.initial_max_streams_bidi.set_value(2 *
                                             kDefaultMaxStreamsPerConnection);
   params.disable_active_migration = true;
-  params.support_handshake_done = true;
 
   EXPECT_THAT(config_.ProcessTransportParameters(
                   params, /* is_resumption = */ false, &error_details),
@@ -629,7 +627,6 @@
             config_.ReceivedMaxBidirectionalStreams());
 
   EXPECT_TRUE(config_.DisableConnectionMigration());
-  EXPECT_TRUE(config_.PeerSupportsHandshakeDone());
 
   ASSERT_TRUE(config_.HasReceivedStatelessResetToken());
 
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 3b7eb17..b6cff48 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -366,7 +366,6 @@
                              clock_->ApproximateNow(),
                              &arena_,
                              alarm_factory_),
-      support_handshake_done_(version().HasHandshakeDone()),
       encrypted_control_frames_(
           GetQuicReloadableFlag(quic_encrypted_control_frames) &&
           packet_creator_.let_connection_handle_pings()),
@@ -461,57 +460,12 @@
   buffered_packets_.clear();
 }
 
-bool QuicConnection::ValidateConfigConnectionIdsOld(const QuicConfig& config) {
-  // This function validates connection IDs as defined in IETF draft-27 and
-  // earlier.
-  DCHECK(config.negotiated());
-  DCHECK(!version().AuthenticatesHandshakeConnectionIds());
-  if (original_destination_connection_id_.has_value() &&
-      retry_source_connection_id_.has_value()) {
-    DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
-    // We received a RETRY packet, validate that the original destination
-    // connection ID from the config matches the one from the RETRY.
-    if (!config.HasReceivedOriginalConnectionId() ||
-        config.ReceivedOriginalConnectionId() !=
-            original_destination_connection_id_.value()) {
-      std::string received_value;
-      if (config.HasReceivedOriginalConnectionId()) {
-        received_value = config.ReceivedOriginalConnectionId().ToString();
-      } else {
-        received_value = "none";
-      }
-      std::string error_details = absl::StrCat(
-          "Bad original_connection_id: expected ",
-          original_destination_connection_id_.value().ToString(), ", received ",
-          received_value, ", RETRY used ", server_connection_id_.ToString());
-      CloseConnection(IETF_QUIC_PROTOCOL_VIOLATION, error_details,
-                      ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-      return false;
-    }
-  } else {
-    // We did not receive a RETRY packet, make sure we did not receive the
-    // original_destination_connection_id transport parameter.
-    if (config.HasReceivedOriginalConnectionId()) {
-      std::string error_details = absl::StrCat(
-          "Bad original_connection_id: did not receive RETRY but received ",
-          config.ReceivedOriginalConnectionId().ToString());
-      CloseConnection(IETF_QUIC_PROTOCOL_VIOLATION, error_details,
-                      ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-      return false;
-    }
-  }
-  return true;
-}
-
 bool QuicConnection::ValidateConfigConnectionIds(const QuicConfig& config) {
   DCHECK(config.negotiated());
   if (!version().UsesTls()) {
     // QUIC+TLS is required to transmit connection ID transport parameters.
     return true;
   }
-  if (!version().AuthenticatesHandshakeConnectionIds()) {
-    return ValidateConfigConnectionIdsOld(config);
-  }
   // This function validates connection IDs as defined in IETF draft-28 and
   // later.
 
@@ -622,9 +576,6 @@
     SetNetworkTimeouts(config.max_time_before_crypto_handshake(),
                        config.max_idle_time_before_crypto_handshake());
   }
-  if (config.HandshakeDoneSupported()) {
-    support_handshake_done_ = true;
-  }
 
   sent_packet_manager_.SetFromConfig(config);
   if (perspective_ == Perspective::IS_SERVER &&
@@ -969,7 +920,7 @@
                                    absl::string_view retry_integrity_tag,
                                    absl::string_view retry_without_tag) {
   DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
-  if (version().HasRetryIntegrityTag()) {
+  if (version().UsesTls()) {
     if (!CryptoUtils::ValidateRetryIntegrityTag(
             version(), server_connection_id_, retry_without_tag,
             retry_integrity_tag)) {
@@ -1795,7 +1746,7 @@
 
 bool QuicConnection::OnHandshakeDoneFrame(const QuicHandshakeDoneFrame& frame) {
   DCHECK(connected_);
-  if (!support_handshake_done_) {
+  if (!version().UsesTls()) {
     CloseConnection(IETF_QUIC_PROTOCOL_VIOLATION,
                     "Handshake done frame is unsupported",
                     ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index b2ce39f..c59b040 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -1498,7 +1498,6 @@
   // Validate connection IDs used during the handshake. Closes the connection
   // on validation failure.
   bool ValidateConfigConnectionIds(const QuicConfig& config);
-  bool ValidateConfigConnectionIdsOld(const QuicConfig& config);
 
   // Called when ACK alarm goes off. Try to bundle crypto data with ACKs.
   void MaybeBundleCryptoDataWithAcks();
@@ -1907,9 +1906,6 @@
 
   bool blackhole_detection_disabled_ = false;
 
-  // True if this connection supports handshake done frame.
-  bool support_handshake_done_;
-
   const bool default_enable_5rto_blackhole_detection_ =
       GetQuicReloadableFlag(quic_default_enable_5rto_blackhole_detection2);
 
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 0e506ad..6f35892 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -3888,7 +3888,7 @@
   options.push_back(kTLPR);
   config.SetConnectionOptionsToSend(options);
   QuicConfigPeer::SetNegotiated(&config, true);
-  if (connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (connection_.version().UsesTls()) {
     QuicConfigPeer::SetReceivedOriginalConnectionId(
         &config, connection_.connection_id());
     QuicConfigPeer::SetReceivedInitialSourceConnectionId(
@@ -5395,7 +5395,7 @@
       config.ProcessPeerHello(msg, CLIENT, &error_details);
   EXPECT_THAT(error, IsQuicNoError());
 
-  if (connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (connection_.version().UsesTls()) {
     QuicConfigPeer::SetReceivedOriginalConnectionId(
         &config, connection_.connection_id());
     QuicConfigPeer::SetReceivedInitialSourceConnectionId(
@@ -5532,7 +5532,7 @@
       config.ProcessPeerHello(msg, CLIENT, &error_details);
   EXPECT_THAT(error, IsQuicNoError());
 
-  if (connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (connection_.version().UsesTls()) {
     QuicConfigPeer::SetReceivedOriginalConnectionId(
         &config, connection_.connection_id());
     QuicConfigPeer::SetReceivedInitialSourceConnectionId(
@@ -5699,7 +5699,7 @@
     EXPECT_CALL(visitor_, GetHandshakeState())
         .WillRepeatedly(Return(HANDSHAKE_COMPLETE));
   }
-  if (connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (connection_.version().UsesTls()) {
     QuicConfigPeer::SetReceivedOriginalConnectionId(
         &config, connection_.connection_id());
     QuicConfigPeer::SetReceivedInitialSourceConnectionId(
@@ -9187,7 +9187,7 @@
   connection_options.push_back(k6PTO);
   config.SetConnectionOptionsToSend(connection_options);
   QuicConfigPeer::SetNegotiated(&config, true);
-  if (connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (connection_.version().UsesTls()) {
     QuicConfigPeer::SetReceivedOriginalConnectionId(
         &config, connection_.connection_id());
     QuicConfigPeer::SetReceivedInitialSourceConnectionId(
@@ -9239,7 +9239,7 @@
   connection_options.push_back(k7PTO);
   config.SetConnectionOptionsToSend(connection_options);
   QuicConfigPeer::SetNegotiated(&config, true);
-  if (connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (connection_.version().UsesTls()) {
     QuicConfigPeer::SetReceivedOriginalConnectionId(
         &config, connection_.connection_id());
     QuicConfigPeer::SetReceivedInitialSourceConnectionId(
@@ -9289,7 +9289,7 @@
   connection_options.push_back(k2PTO);
   connection_options.push_back(k8PTO);
   QuicConfigPeer::SetNegotiated(&config, true);
-  if (connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (connection_.version().UsesTls()) {
     QuicConfigPeer::SetReceivedOriginalConnectionId(
         &config, connection_.connection_id());
     QuicConfigPeer::SetReceivedInitialSourceConnectionId(
@@ -9440,7 +9440,7 @@
   QuicTagVector connection_options;
   connection_options.push_back(k3AFF);
   config.SetInitialReceivedConnectionOptions(connection_options);
-  if (connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (connection_.version().UsesTls()) {
     QuicConfigPeer::SetReceivedOriginalConnectionId(
         &config, connection_.connection_id());
     QuicConfigPeer::SetReceivedInitialSourceConnectionId(&config,
@@ -9505,7 +9505,7 @@
   QuicTagVector connection_options;
   connection_options.push_back(k10AF);
   config.SetInitialReceivedConnectionOptions(connection_options);
-  if (connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (connection_.version().UsesTls()) {
     QuicConfigPeer::SetReceivedOriginalConnectionId(
         &config, connection_.connection_id());
     QuicConfigPeer::SetReceivedInitialSourceConnectionId(&config,
@@ -9786,7 +9786,7 @@
 }
 
 TEST_P(QuicConnectionTest, ClientReceivedHandshakeDone) {
-  if (!connection_.version().HasHandshakeDone()) {
+  if (!connection_.version().UsesTls()) {
     return;
   }
   EXPECT_CALL(visitor_, OnHandshakeDoneReceived());
@@ -9797,7 +9797,7 @@
 }
 
 TEST_P(QuicConnectionTest, ServerReceivedHandshakeDone) {
-  if (!connection_.version().HasHandshakeDone()) {
+  if (!connection_.version().UsesTls()) {
     return;
   }
   set_perspective(Perspective::IS_SERVER);
@@ -9908,7 +9908,7 @@
     ASSERT_FALSE(missing_original_id_in_config && wrong_original_id_in_config);
     ASSERT_FALSE(missing_retry_id_in_config && wrong_retry_id_in_config);
   }
-  if (!version().HasRetryIntegrityTag()) {
+  if (!version().UsesTls()) {
     return;
   }
 
@@ -9993,7 +9993,7 @@
   // Test validating the original_connection_id from the config.
   QuicConfig received_config;
   QuicConfigPeer::SetNegotiated(&received_config, true);
-  if (connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (connection_.version().UsesTls()) {
     QuicConfigPeer::SetReceivedInitialSourceConnectionId(
         &received_config, connection_.connection_id());
     if (!missing_retry_id_in_config) {
@@ -10060,7 +10060,7 @@
 }
 
 TEST_P(QuicConnectionTest, ClientParsesRetryMissingRetryId) {
-  if (!connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (!connection_.version().UsesTls()) {
     // Versions that do not authenticate connection IDs never send the
     // retry_source_connection_id transport parameter.
     return;
@@ -10073,7 +10073,7 @@
 }
 
 TEST_P(QuicConnectionTest, ClientParsesRetryWrongRetryId) {
-  if (!connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (!connection_.version().UsesTls()) {
     // Versions that do not authenticate connection IDs never send the
     // retry_source_connection_id transport parameter.
     return;
@@ -10090,7 +10090,7 @@
     // QUIC+TLS is required to transmit connection ID transport parameters.
     return;
   }
-  if (connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (connection_.version().UsesTls()) {
     // Versions that authenticate connection IDs always send the
     // original_destination_connection_id transport parameter.
     return;
@@ -10110,7 +10110,7 @@
 }
 
 TEST_P(QuicConnectionTest, ClientReceivesRetrySourceConnectionIdWithoutRetry) {
-  if (!connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (!connection_.version().UsesTls()) {
     // Versions that do not authenticate connection IDs never send the
     // retry_source_connection_id transport parameter.
     return;
@@ -10544,7 +10544,7 @@
     EXPECT_CALL(visitor_, GetHandshakeState())
         .WillRepeatedly(Return(HANDSHAKE_COMPLETE));
   }
-  if (connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (connection_.version().UsesTls()) {
     QuicConfigPeer::SetReceivedOriginalConnectionId(
         &config, connection_.connection_id());
     QuicConfigPeer::SetReceivedInitialSourceConnectionId(
@@ -10938,7 +10938,7 @@
       config.ProcessPeerHello(msg, CLIENT, &error_details);
   EXPECT_THAT(error, IsQuicNoError());
 
-  if (connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (connection_.version().UsesTls()) {
     QuicConfigPeer::SetReceivedOriginalConnectionId(
         &config, connection_.connection_id());
     QuicConfigPeer::SetReceivedInitialSourceConnectionId(
@@ -10970,7 +10970,7 @@
 
   QuicConfig config;
   QuicConfigPeer::SetNegotiated(&config, true);
-  if (connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (connection_.version().UsesTls()) {
     QuicConfigPeer::SetReceivedOriginalConnectionId(
         &config, connection_.connection_id());
     QuicConfigPeer::SetReceivedInitialSourceConnectionId(&config,
@@ -11123,7 +11123,7 @@
     EXPECT_CALL(visitor_, GetHandshakeState())
         .WillRepeatedly(Return(HANDSHAKE_COMPLETE));
   }
-  if (connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (connection_.version().UsesTls()) {
     QuicConfigPeer::SetReceivedOriginalConnectionId(
         &config, connection_.connection_id());
     QuicConfigPeer::SetReceivedInitialSourceConnectionId(
@@ -12015,7 +12015,7 @@
               IsQuicNoError());
   config.SetKeyUpdateSupportedLocally();
   QuicConfigPeer::SetNegotiated(&config, true);
-  if (connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (connection_.version().UsesTls()) {
     QuicConfigPeer::SetReceivedOriginalConnectionId(
         &config, connection_.connection_id());
     QuicConfigPeer::SetReceivedInitialSourceConnectionId(
@@ -12176,7 +12176,7 @@
               IsQuicNoError());
   config.SetKeyUpdateSupportedLocally();
   QuicConfigPeer::SetNegotiated(&config, true);
-  if (connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (connection_.version().UsesTls()) {
     QuicConfigPeer::SetReceivedOriginalConnectionId(
         &config, connection_.connection_id());
     QuicConfigPeer::SetReceivedInitialSourceConnectionId(
@@ -12274,7 +12274,7 @@
               IsQuicNoError());
   config.SetKeyUpdateSupportedLocally();
   QuicConfigPeer::SetNegotiated(&config, true);
-  if (connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (connection_.version().UsesTls()) {
     QuicConfigPeer::SetReceivedOriginalConnectionId(
         &config, connection_.connection_id());
     QuicConfigPeer::SetReceivedInitialSourceConnectionId(
@@ -12330,7 +12330,7 @@
   // Key update is supported locally.
   config.SetKeyUpdateSupportedLocally();
   QuicConfigPeer::SetNegotiated(&config, true);
-  if (connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (connection_.version().UsesTls()) {
     QuicConfigPeer::SetReceivedOriginalConnectionId(
         &config, connection_.connection_id());
     QuicConfigPeer::SetReceivedInitialSourceConnectionId(
@@ -12395,7 +12395,7 @@
                   params, /* is_resumption = */ false, &error_details),
               IsQuicNoError());
   QuicConfigPeer::SetNegotiated(&config, true);
-  if (connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (connection_.version().UsesTls()) {
     QuicConfigPeer::SetReceivedOriginalConnectionId(
         &config, connection_.connection_id());
     QuicConfigPeer::SetReceivedInitialSourceConnectionId(
@@ -12602,7 +12602,7 @@
               IsQuicNoError());
   config.SetKeyUpdateSupportedLocally();
   QuicConfigPeer::SetNegotiated(&config, true);
-  if (connection_.version().AuthenticatesHandshakeConnectionIds()) {
+  if (connection_.version().UsesTls()) {
     QuicConfigPeer::SetReceivedOriginalConnectionId(
         &config, connection_.connection_id());
     QuicConfigPeer::SetReceivedInitialSourceConnectionId(
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index ef8b29e..6b29cae 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -1556,7 +1556,7 @@
                                     const QuicPacketHeader& header) {
   DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
 
-  if (version_.HasRetryIntegrityTag()) {
+  if (version_.UsesTls()) {
     DCHECK(version_.HasLengthPrefixedConnectionIds()) << version_;
     const size_t bytes_remaining = reader->BytesRemaining();
     if (bytes_remaining <= kRetryIntegrityTagLength) {
diff --git a/quic/core/quic_framer.h b/quic/core/quic_framer.h
index bed6162..9f12d2b 100644
--- a/quic/core/quic_framer.h
+++ b/quic/core/quic_framer.h
@@ -96,11 +96,11 @@
   // Called only when |perspective_| is IS_CLIENT and a retry packet has been
   // parsed. |new_connection_id| contains the value of the Source Connection
   // ID field, and |retry_token| contains the value of the Retry Token field.
-  // On versions where HasRetryIntegrityTag() is false,
+  // On versions where UsesTls() is false,
   // |original_connection_id| contains the value of the Original Destination
   // Connection ID field, and both |retry_integrity_tag| and
   // |retry_without_tag| are empty.
-  // On versions where HasRetryIntegrityTag() is true,
+  // On versions where UsesTls() is true,
   // |original_connection_id| is empty, |retry_integrity_tag| contains the
   // value of the Retry Integrity Tag field, and |retry_without_tag| contains
   // the entire RETRY packet except the Retry Integrity Tag field.
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index dfaf811..798693f 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -6061,7 +6061,7 @@
 
   unsigned char* p = packet;
   size_t p_length = ABSL_ARRAYSIZE(packet);
-  if (framer_.version().HasRetryIntegrityTag()) {
+  if (framer_.version().UsesTls()) {
     p = packet_with_tag;
     p_length = ABSL_ARRAYSIZE(packet_with_tag);
   } else if (framer_.version().HasLongHeaderLengths()) {
@@ -6078,7 +6078,7 @@
   ASSERT_TRUE(visitor_.retry_new_connection_id_.get());
   ASSERT_TRUE(visitor_.retry_token_.get());
 
-  if (framer_.version().HasRetryIntegrityTag()) {
+  if (framer_.version().UsesTls()) {
     ASSERT_TRUE(visitor_.retry_token_integrity_tag_.get());
     static const unsigned char expected_integrity_tag[16] = {
         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 4d7d22b..1328f8a 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -142,10 +142,6 @@
     connection_->set_can_receive_ack_frequency_frame();
     config_.SetMinAckDelayMs(kDefaultMinAckDelayTimeMs);
   }
-  if (perspective() == Perspective::IS_CLIENT && version().UsesTls() &&
-      !version().HasHandshakeDone()) {
-    config_.SetSupportHandshakeDone();
-  }
 
   // On the server side, version negotiation has been done by the dispatcher,
   // and the server session is created with the right version.
@@ -1661,8 +1657,7 @@
       << ENDPOINT << "Handshake completes without parameter negotiation.";
   connection()->mutable_stats().handshake_completion_time =
       connection()->clock()->ApproximateNow();
-  if ((connection()->version().HasHandshakeDone() ||
-       config_.PeerSupportsHandshakeDone()) &&
+  if (connection()->version().UsesTls() &&
       perspective_ == Perspective::IS_SERVER) {
     // Server sends HANDSHAKE_DONE to signal confirmation of the handshake
     // to the client.
@@ -1719,7 +1714,7 @@
 }
 
 bool QuicSession::FillTransportParameters(TransportParameters* params) {
-  if (version().AuthenticatesHandshakeConnectionIds()) {
+  if (version().UsesTls()) {
     if (perspective() == Perspective::IS_SERVER) {
       config_.SetOriginalConnectionIdToSend(
           connection_->GetOriginalDestinationConnectionId());
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 675ea55..9f0e4a1 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -85,7 +85,7 @@
         kInitialStreamFlowControlWindowForTest);
     session()->config()->SetInitialSessionFlowControlWindowToSend(
         kInitialSessionFlowControlWindowForTest);
-    if (session()->version().AuthenticatesHandshakeConnectionIds()) {
+    if (session()->version().UsesTls()) {
       if (session()->perspective() == Perspective::IS_CLIENT) {
         session()->config()->SetOriginalConnectionIdToSend(
             session()->connection()->connection_id());
@@ -95,9 +95,6 @@
         session()->config()->SetInitialSourceConnectionIdToSend(
             session()->connection()->client_connection_id());
       }
-    }
-    if (session()->connection()->version().handshake_protocol ==
-        PROTOCOL_TLS1_3) {
       TransportParameters transport_parameters;
       EXPECT_TRUE(
           session()->config()->FillTransportParameters(&transport_parameters));
@@ -498,8 +495,9 @@
 
   void CompleteHandshake() {
     CryptoHandshakeMessage msg;
-    if (connection_->version().HasHandshakeDone() &&
+    if (connection_->version().UsesTls() &&
         connection_->perspective() == Perspective::IS_SERVER) {
+      // HANDSHAKE_DONE frame.
       EXPECT_CALL(*connection_, SendControlFrame(_))
           .WillOnce(Invoke(&ClearControlFrame));
     }
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index 9f71bbb..27d56c9 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -100,11 +100,6 @@
   return transport_version > QUIC_VERSION_46;
 }
 
-bool ParsedQuicVersion::HasRetryIntegrityTag() const {
-  DCHECK(IsKnown());
-  return handshake_protocol == PROTOCOL_TLS1_3;
-}
-
 bool ParsedQuicVersion::SendsVariableLengthPacketNumberInLongHeader() const {
   DCHECK(IsKnown());
   return transport_version > QUIC_VERSION_46;
@@ -134,8 +129,7 @@
 
 bool ParsedQuicVersion::CanSendCoalescedPackets() const {
   DCHECK(IsKnown());
-  return QuicVersionHasLongHeaderLengths(transport_version) &&
-         handshake_protocol == PROTOCOL_TLS1_3;
+  return HasLongHeaderLengths() && UsesTls();
 }
 
 bool ParsedQuicVersion::SupportsGoogleAltSvcFormat() const {
@@ -173,26 +167,6 @@
   return VersionHasIetfQuicFrames(transport_version);
 }
 
-bool ParsedQuicVersion::HasHandshakeDone() const {
-  DCHECK(IsKnown());
-  // HANDSHAKE_DONE is supported in T051 and all IETF drafts since draft-25.
-  return UsesTls();
-}
-
-bool ParsedQuicVersion::HasVarIntTransportParams() const {
-  DCHECK(IsKnown());
-  // Variable-length integer transport parameters are supported in T051 and
-  // all IETF drafts since draft-27.
-  return UsesTls();
-}
-
-bool ParsedQuicVersion::AuthenticatesHandshakeConnectionIds() const {
-  DCHECK(IsKnown());
-  // Authentication of handshake connection IDs is supported in T051 and
-  // all IETF drafts since draft-28.
-  return UsesTls();
-}
-
 bool ParsedQuicVersion::UsesTls() const {
   DCHECK(IsKnown());
   return handshake_protocol == PROTOCOL_TLS1_3;
@@ -290,7 +264,7 @@
 ParsedQuicVersionVector AllSupportedVersionsWithTls() {
   ParsedQuicVersionVector versions;
   for (const ParsedQuicVersion& version : AllSupportedVersions()) {
-    if (version.handshake_protocol == PROTOCOL_TLS1_3) {
+    if (version.UsesTls()) {
       versions.push_back(version);
     }
   }
@@ -301,7 +275,7 @@
 ParsedQuicVersionVector CurrentSupportedVersionsWithTls() {
   ParsedQuicVersionVector versions;
   for (const ParsedQuicVersion& version : CurrentSupportedVersions()) {
-    if (version.handshake_protocol == PROTOCOL_TLS1_3) {
+    if (version.UsesTls()) {
       versions.push_back(version);
     }
   }
diff --git a/quic/core/quic_versions.h b/quic/core/quic_versions.h
index 003424d..3257cc5 100644
--- a/quic/core/quic_versions.h
+++ b/quic/core/quic_versions.h
@@ -294,9 +294,6 @@
   // Returns whether this version supports IETF RETRY packets.
   bool SupportsRetry() const;
 
-  // Returns whether RETRY packets carry the Retry Integrity Tag field.
-  bool HasRetryIntegrityTag() const;
-
   // Returns true if this version sends variable length packet number in long
   // header.
   bool SendsVariableLengthPacketNumberInLongHeader() const;
@@ -354,17 +351,6 @@
   // frames or not.
   bool HasIetfQuicFrames() const;
 
-  // Returns true if this parsed version supports handshake done.
-  bool HasHandshakeDone() const;
-
-  // Returns true if this version uses variable-length integers when
-  // encoding transport parameter types and lengths.
-  bool HasVarIntTransportParams() const;
-
-  // Returns true if this version uses transport parameters to authenticate all
-  // the connection IDs used during the handshake.
-  bool AuthenticatesHandshakeConnectionIds() const;
-
   // Returns whether this version uses PROTOCOL_TLS1_3.
   bool UsesTls() const;
 
diff --git a/quic/core/quic_versions_test.cc b/quic/core/quic_versions_test.cc
index f0f0801..d8af34f 100644
--- a/quic/core/quic_versions_test.cc
+++ b/quic/core/quic_versions_test.cc
@@ -69,7 +69,6 @@
   EXPECT_FALSE(parsed_version_q043.AllowsLowFlowControlLimits());
   EXPECT_FALSE(parsed_version_q043.HasHeaderProtection());
   EXPECT_FALSE(parsed_version_q043.SupportsRetry());
-  EXPECT_FALSE(parsed_version_q043.HasRetryIntegrityTag());
   EXPECT_FALSE(
       parsed_version_q043.SendsVariableLengthPacketNumberInLongHeader());
   EXPECT_FALSE(parsed_version_q043.AllowsVariableLengthConnectionIds());
@@ -84,9 +83,6 @@
   EXPECT_FALSE(parsed_version_q043.HasLongHeaderLengths());
   EXPECT_FALSE(parsed_version_q043.UsesCryptoFrames());
   EXPECT_FALSE(parsed_version_q043.HasIetfQuicFrames());
-  EXPECT_FALSE(parsed_version_q043.HasHandshakeDone());
-  EXPECT_FALSE(parsed_version_q043.HasVarIntTransportParams());
-  EXPECT_FALSE(parsed_version_q043.AuthenticatesHandshakeConnectionIds());
   EXPECT_FALSE(parsed_version_q043.UsesTls());
   EXPECT_TRUE(parsed_version_q043.UsesQuicCrypto());
 
@@ -96,7 +92,6 @@
   EXPECT_TRUE(parsed_version_draft_29.AllowsLowFlowControlLimits());
   EXPECT_TRUE(parsed_version_draft_29.HasHeaderProtection());
   EXPECT_TRUE(parsed_version_draft_29.SupportsRetry());
-  EXPECT_TRUE(parsed_version_draft_29.HasRetryIntegrityTag());
   EXPECT_TRUE(
       parsed_version_draft_29.SendsVariableLengthPacketNumberInLongHeader());
   EXPECT_TRUE(parsed_version_draft_29.AllowsVariableLengthConnectionIds());
@@ -111,9 +106,6 @@
   EXPECT_TRUE(parsed_version_draft_29.HasLongHeaderLengths());
   EXPECT_TRUE(parsed_version_draft_29.UsesCryptoFrames());
   EXPECT_TRUE(parsed_version_draft_29.HasIetfQuicFrames());
-  EXPECT_TRUE(parsed_version_draft_29.HasHandshakeDone());
-  EXPECT_TRUE(parsed_version_draft_29.HasVarIntTransportParams());
-  EXPECT_TRUE(parsed_version_draft_29.AuthenticatesHandshakeConnectionIds());
   EXPECT_TRUE(parsed_version_draft_29.UsesTls());
   EXPECT_FALSE(parsed_version_draft_29.UsesQuicCrypto());
 }
diff --git a/quic/test_tools/quic_config_peer.cc b/quic/test_tools/quic_config_peer.cc
index b10453e..8bd5564 100644
--- a/quic/test_tools/quic_config_peer.cc
+++ b/quic/test_tools/quic_config_peer.cc
@@ -138,10 +138,5 @@
   config->max_datagram_frame_size_.SetReceivedValue(max_datagram_frame_size);
 }
 
-// static
-void QuicConfigPeer::DisableSupportHandshakeDone(QuicConfig* config) {
-  config->support_handshake_done_.SetSendValue(0);
-}
-
 }  // namespace test
 }  // namespace quic
diff --git a/quic/test_tools/quic_config_peer.h b/quic/test_tools/quic_config_peer.h
index 98c35a1..b833969 100644
--- a/quic/test_tools/quic_config_peer.h
+++ b/quic/test_tools/quic_config_peer.h
@@ -79,7 +79,6 @@
 
   static void SetReceivedMaxDatagramFrameSize(QuicConfig* config,
                                               uint64_t max_datagram_frame_size);
-  static void DisableSupportHandshakeDone(QuicConfig* config);
 };
 
 }  // namespace test
diff --git a/quic/test_tools/simulator/quic_endpoint.cc b/quic/test_tools/simulator/quic_endpoint.cc
index c02ac7e..00da243 100644
--- a/quic/test_tools/simulator/quic_endpoint.cc
+++ b/quic/test_tools/simulator/quic_endpoint.cc
@@ -75,7 +75,7 @@
       peer_hello, perspective == Perspective::IS_CLIENT ? SERVER : CLIENT,
       &error);
   DCHECK_EQ(error_code, QUIC_NO_ERROR) << "Configuration failed: " << error;
-  if (connection_->version().AuthenticatesHandshakeConnectionIds()) {
+  if (connection_->version().UsesTls()) {
     if (connection_->perspective() == Perspective::IS_CLIENT) {
       test::QuicConfigPeer::SetReceivedOriginalConnectionId(
           &config, connection_->connection_id());
diff --git a/quic/tools/quic_client_base.cc b/quic/tools/quic_client_base.cc
index f4cd859..dcd24a3 100644
--- a/quic/tools/quic_client_base.cc
+++ b/quic/tools/quic_client_base.cc
@@ -359,9 +359,10 @@
 }
 
 bool QuicClientBase::WaitForHandshakeConfirmed() {
-  if (!session_->connection()->version().HasHandshakeDone()) {
+  if (!session_->connection()->version().UsesTls()) {
     return WaitForOneRttKeysAvailable();
   }
+  // Otherwise, wait for receipt of HANDSHAKE_DONE frame.
   while (connected() && session_->GetHandshakeState() < HANDSHAKE_CONFIRMED) {
     WaitForEvents();
   }