diff --git a/quic/core/crypto/crypto_utils.cc b/quic/core/crypto/crypto_utils.cc
index 50bbfef..05bbdfe 100644
--- a/quic/core/crypto/crypto_utils.cc
+++ b/quic/core/crypto/crypto_utils.cc
@@ -57,8 +57,7 @@
 // |out_len|, respectively. The resulting expanded secret is returned.
 std::vector<uint8_t> HkdfExpandLabel(const EVP_MD* prf,
                                      const std::vector<uint8_t>& secret,
-                                     const std::string& label,
-                                     size_t out_len) {
+                                     const std::string& label, size_t out_len) {
   bssl::ScopedCBB quic_hkdf_label;
   CBB inner_label;
   const char label_prefix[] = "tls13 ";
@@ -91,13 +90,23 @@
 
 }  // namespace
 
+const std::string getLabelForVersion(const ParsedQuicVersion& version,
+                                     const absl::string_view& predicate) {
+  static_assert(SupportedVersions().size() == 6u,
+                "Supported versions out of sync with HKDF labels");
+  if (version == ParsedQuicVersion::V2Draft01()) {
+    return absl::StrCat("quicv2 ", predicate);
+  } else {
+    return absl::StrCat("quic ", predicate);
+  }
+}
+
 void CryptoUtils::InitializeCrypterSecrets(
-    const EVP_MD* prf,
-    const std::vector<uint8_t>& pp_secret,
-    QuicCrypter* crypter) {
-  SetKeyAndIV(prf, pp_secret, crypter);
-  std::vector<uint8_t> header_protection_key =
-      GenerateHeaderProtectionKey(prf, pp_secret, crypter->GetKeySize());
+    const EVP_MD* prf, const std::vector<uint8_t>& pp_secret,
+    const ParsedQuicVersion& version, QuicCrypter* crypter) {
+  SetKeyAndIV(prf, pp_secret, version, crypter);
+  std::vector<uint8_t> header_protection_key = GenerateHeaderProtectionKey(
+      prf, pp_secret, version, crypter->GetKeySize());
   crypter->SetHeaderProtectionKey(
       absl::string_view(reinterpret_cast<char*>(header_protection_key.data()),
                         header_protection_key.size()));
@@ -105,11 +114,13 @@
 
 void CryptoUtils::SetKeyAndIV(const EVP_MD* prf,
                               const std::vector<uint8_t>& pp_secret,
+                              const ParsedQuicVersion& version,
                               QuicCrypter* crypter) {
   std::vector<uint8_t> key =
-      HkdfExpandLabel(prf, pp_secret, "quic key", crypter->GetKeySize());
-  std::vector<uint8_t> iv =
-      HkdfExpandLabel(prf, pp_secret, "quic iv", crypter->GetIVSize());
+      HkdfExpandLabel(prf, pp_secret, getLabelForVersion(version, "key"),
+                      crypter->GetKeySize());
+  std::vector<uint8_t> iv = HkdfExpandLabel(
+      prf, pp_secret, getLabelForVersion(version, "iv"), crypter->GetIVSize());
   crypter->SetKey(
       absl::string_view(reinterpret_cast<char*>(key.data()), key.size()));
   crypter->SetIV(
@@ -117,16 +128,17 @@
 }
 
 std::vector<uint8_t> CryptoUtils::GenerateHeaderProtectionKey(
-    const EVP_MD* prf,
-    const std::vector<uint8_t>& pp_secret,
-    size_t out_len) {
-  return HkdfExpandLabel(prf, pp_secret, "quic hp", out_len);
+    const EVP_MD* prf, const std::vector<uint8_t>& pp_secret,
+    const ParsedQuicVersion& version, size_t out_len) {
+  return HkdfExpandLabel(prf, pp_secret, getLabelForVersion(version, "hp"),
+                         out_len);
 }
 
 std::vector<uint8_t> CryptoUtils::GenerateNextKeyPhaseSecret(
-    const EVP_MD* prf,
+    const EVP_MD* prf, const ParsedQuicVersion& version,
     const std::vector<uint8_t>& current_secret) {
-  return HkdfExpandLabel(prf, current_secret, "quic ku", current_secret.size());
+  return HkdfExpandLabel(prf, current_secret, getLabelForVersion(version, "ku"),
+                         current_secret.size());
 }
 
 namespace {
@@ -138,6 +150,9 @@
 const uint8_t kRFCv1InitialSalt[] = {0x38, 0x76, 0x2c, 0xf7, 0xf5, 0x59, 0x34,
                                      0xb3, 0x4d, 0x17, 0x9a, 0xe6, 0xa4, 0xc8,
                                      0x0c, 0xad, 0xcc, 0xbb, 0x7f, 0x0a};
+const uint8_t kV2Draft01InitialSalt[] = {
+    0xa7, 0x07, 0xc2, 0x03, 0xa5, 0x9b, 0x47, 0x18, 0x4a, 0x1d,
+    0x62, 0xca, 0x57, 0x04, 0x06, 0xea, 0x7a, 0xe3, 0xe5, 0xd3};
 
 // Salts used by deployed versions of QUIC. When introducing a new version,
 // generate a new salt by running `openssl rand -hex 20`.
@@ -154,9 +169,12 @@
 
 const uint8_t* InitialSaltForVersion(const ParsedQuicVersion& version,
                                      size_t* out_len) {
-  static_assert(SupportedVersions().size() == 5u,
+  static_assert(SupportedVersions().size() == 6u,
                 "Supported versions out of sync with initial encryption salts");
-  if (version == ParsedQuicVersion::RFCv1()) {
+  if (version == ParsedQuicVersion::V2Draft01()) {
+    *out_len = ABSL_ARRAYSIZE(kV2Draft01InitialSalt);
+    return kV2Draft01InitialSalt;
+  } else if (version == ParsedQuicVersion::RFCv1()) {
     *out_len = ABSL_ARRAYSIZE(kRFCv1InitialSalt);
     return kRFCv1InitialSalt;
   } else if (version == ParsedQuicVersion::Draft29()) {
@@ -191,6 +209,11 @@
                                            0xe3, 0x68, 0xc8, 0x4e};
 const uint8_t kRFCv1RetryIntegrityNonce[] = {
     0x46, 0x15, 0x99, 0xd3, 0x5d, 0x63, 0x2b, 0xf2, 0x23, 0x98, 0x25, 0xbb};
+const uint8_t kV2Draft01RetryIntegrityKey[] = {
+    0xba, 0x85, 0x8d, 0xc7, 0xb4, 0x3d, 0xe5, 0xdb,
+    0xf8, 0x76, 0x17, 0xff, 0x4a, 0xb2, 0x53, 0xdb};
+const uint8_t kV2Draft01RetryIntegrityNonce[] = {
+    0x14, 0x1b, 0x99, 0xc2, 0x39, 0xb0, 0x3e, 0x78, 0x5d, 0x6a, 0x2e, 0x9f};
 // Retry integrity key used by ParsedQuicVersion::ReservedForNegotiation().
 const uint8_t kReservedForNegotiationRetryIntegrityKey[] = {
     0xf2, 0xcd, 0x8f, 0xe0, 0x36, 0xd0, 0x25, 0x35,
@@ -204,13 +227,21 @@
 bool RetryIntegrityKeysForVersion(const ParsedQuicVersion& version,
                                   absl::string_view* key,
                                   absl::string_view* nonce) {
-  static_assert(SupportedVersions().size() == 5u,
+  static_assert(SupportedVersions().size() == 6u,
                 "Supported versions out of sync with retry integrity keys");
   if (!version.UsesTls()) {
     QUIC_BUG(quic_bug_10699_2)
         << "Attempted to get retry integrity keys for invalid version "
         << version;
     return false;
+  } else if (version == ParsedQuicVersion::V2Draft01()) {
+    *key = absl::string_view(
+        reinterpret_cast<const char*>(kV2Draft01RetryIntegrityKey),
+        ABSL_ARRAYSIZE(kV2Draft01RetryIntegrityKey));
+    *nonce = absl::string_view(
+        reinterpret_cast<const char*>(kV2Draft01RetryIntegrityNonce),
+        ABSL_ARRAYSIZE(kV2Draft01RetryIntegrityNonce));
+    return true;
   } else if (version == ParsedQuicVersion::RFCv1()) {
     *key = absl::string_view(
         reinterpret_cast<const char*>(kRFCv1RetryIntegrityKey),
@@ -291,20 +322,20 @@
   std::vector<uint8_t> encryption_secret = HkdfExpandLabel(
       hash, handshake_secret, encryption_label, EVP_MD_size(hash));
   crypters->encrypter = std::make_unique<Aes128GcmEncrypter>();
-  InitializeCrypterSecrets(hash, encryption_secret, crypters->encrypter.get());
+  InitializeCrypterSecrets(hash, encryption_secret, version,
+                           crypters->encrypter.get());
 
   std::vector<uint8_t> decryption_secret = HkdfExpandLabel(
       hash, handshake_secret, decryption_label, EVP_MD_size(hash));
   crypters->decrypter = std::make_unique<Aes128GcmDecrypter>();
-  InitializeCrypterSecrets(hash, decryption_secret, crypters->decrypter.get());
+  InitializeCrypterSecrets(hash, decryption_secret, version,
+                           crypters->decrypter.get());
 }
 
 // static
 bool CryptoUtils::ValidateRetryIntegrityTag(
-    ParsedQuicVersion version,
-    QuicConnectionId original_connection_id,
-    absl::string_view retry_without_tag,
-    absl::string_view integrity_tag) {
+    ParsedQuicVersion version, QuicConnectionId original_connection_id,
+    absl::string_view retry_without_tag, absl::string_view integrity_tag) {
   unsigned char computed_integrity_tag[kRetryIntegrityTagLength];
   if (integrity_tag.length() != ABSL_ARRAYSIZE(computed_integrity_tag)) {
     QUIC_BUG(quic_bug_10699_4)
@@ -348,10 +379,8 @@
 }
 
 // static
-void CryptoUtils::GenerateNonce(QuicWallTime now,
-                                QuicRandom* random_generator,
-                                absl::string_view orbit,
-                                std::string* nonce) {
+void CryptoUtils::GenerateNonce(QuicWallTime now, QuicRandom* random_generator,
+                                absl::string_view orbit, std::string* nonce) {
   // a 4-byte timestamp + 28 random bytes.
   nonce->reserve(kNonceSize);
   nonce->resize(kNonceSize);
@@ -375,17 +404,13 @@
 }
 
 // static
-bool CryptoUtils::DeriveKeys(const ParsedQuicVersion& version,
-                             absl::string_view premaster_secret,
-                             QuicTag aead,
-                             absl::string_view client_nonce,
-                             absl::string_view server_nonce,
-                             absl::string_view pre_shared_key,
-                             const std::string& hkdf_input,
-                             Perspective perspective,
-                             Diversification diversification,
-                             CrypterPair* crypters,
-                             std::string* subkey_secret) {
+bool CryptoUtils::DeriveKeys(
+    const ParsedQuicVersion& version, absl::string_view premaster_secret,
+    QuicTag aead, absl::string_view client_nonce,
+    absl::string_view server_nonce, absl::string_view pre_shared_key,
+    const std::string& hkdf_input, Perspective perspective,
+    Diversification diversification, CrypterPair* crypters,
+    std::string* subkey_secret) {
   // If the connection is using PSK, concatenate it with the pre-master secret.
   std::unique_ptr<char[]> psk_premaster_secret;
   if (!pre_shared_key.empty()) {
@@ -573,8 +598,7 @@
 }
 
 QuicErrorCode CryptoUtils::ValidateClientHello(
-    const CryptoHandshakeMessage& client_hello,
-    ParsedQuicVersion version,
+    const CryptoHandshakeMessage& client_hello, ParsedQuicVersion version,
     const ParsedQuicVersionVector& supported_versions,
     std::string* error_details) {
   if (client_hello.tag() != kCHLO) {
@@ -597,8 +621,7 @@
 }
 
 QuicErrorCode CryptoUtils::ValidateClientHelloVersion(
-    QuicVersionLabel client_version,
-    ParsedQuicVersion connection_version,
+    QuicVersionLabel client_version, ParsedQuicVersion connection_version,
     const ParsedQuicVersionVector& supported_versions,
     std::string* error_details) {
   if (client_version != CreateQuicVersionLabel(connection_version)) {
@@ -736,8 +759,7 @@
 
 // static
 std::string CryptoUtils::HashHandshakeMessage(
-    const CryptoHandshakeMessage& message,
-    Perspective /*perspective*/) {
+    const CryptoHandshakeMessage& message, Perspective /*perspective*/) {
   std::string output;
   const QuicData& serialized = message.GetSerialized();
   uint8_t digest[SHA256_DIGEST_LENGTH];
diff --git a/quic/core/crypto/crypto_utils.h b/quic/core/crypto/crypto_utils.h
index 8884f6f..fce6201 100644
--- a/quic/core/crypto/crypto_utils.h
+++ b/quic/core/crypto/crypto_utils.h
@@ -79,9 +79,11 @@
   // on the given QuicCrypter |*crypter|.
   // This follows the derivation described in section 7.3 of RFC 8446, except
   // with the label prefix in HKDF-Expand-Label changed from "tls13 " to "quic "
-  // as described in draft-ietf-quic-tls-14, section 5.1.
+  // as described in draft-ietf-quic-tls-14, section 5.1, or "quicv2 " as
+  // described in draft-ietf-quic-v2-01.
   static void InitializeCrypterSecrets(const EVP_MD* prf,
                                        const std::vector<uint8_t>& pp_secret,
+                                       const ParsedQuicVersion& version,
                                        QuicCrypter* crypter);
 
   // Derives the key and IV from the packet protection secret and sets those
@@ -90,17 +92,17 @@
   // called before using |crypter|.
   static void SetKeyAndIV(const EVP_MD* prf,
                           const std::vector<uint8_t>& pp_secret,
+                          const ParsedQuicVersion& version,
                           QuicCrypter* crypter);
 
   // Derives the header protection key from the packet protection secret.
   static std::vector<uint8_t> GenerateHeaderProtectionKey(
-      const EVP_MD* prf,
-      const std::vector<uint8_t>& pp_secret,
-      size_t out_len);
+      const EVP_MD* prf, const std::vector<uint8_t>& pp_secret,
+      const ParsedQuicVersion& version, size_t out_len);
 
   // Given a secret for key phase n, return the secret for phase n+1.
   static std::vector<uint8_t> GenerateNextKeyPhaseSecret(
-      const EVP_MD* prf,
+      const EVP_MD* prf, const ParsedQuicVersion& version,
       const std::vector<uint8_t>& current_secret);
 
   // IETF QUIC encrypts ENCRYPTION_INITIAL messages with a version-specific key
@@ -130,10 +132,8 @@
   //   <4 bytes> current time
   //   <8 bytes> |orbit| (or random if |orbit| is empty)
   //   <20 bytes> random
-  static void GenerateNonce(QuicWallTime now,
-                            QuicRandom* random_generator,
-                            absl::string_view orbit,
-                            std::string* nonce);
+  static void GenerateNonce(QuicWallTime now, QuicRandom* random_generator,
+                            absl::string_view orbit, std::string* nonce);
 
   // DeriveKeys populates |crypters->encrypter|, |crypters->decrypter|, and
   // |subkey_secret| (optional -- may be null) given the contents of
@@ -155,15 +155,12 @@
   // |SetDiversificationNonce| with a diversification nonce will be needed to
   // complete keying.
   static bool DeriveKeys(const ParsedQuicVersion& version,
-                         absl::string_view premaster_secret,
-                         QuicTag aead,
+                         absl::string_view premaster_secret, QuicTag aead,
                          absl::string_view client_nonce,
                          absl::string_view server_nonce,
                          absl::string_view pre_shared_key,
-                         const std::string& hkdf_input,
-                         Perspective perspective,
-                         Diversification diversification,
-                         CrypterPair* crypters,
+                         const std::string& hkdf_input, Perspective perspective,
+                         Diversification diversification, CrypterPair* crypters,
                          std::string* subkey_secret);
 
   // Computes the FNV-1a hash of the provided DER-encoded cert for use in the
@@ -199,8 +196,7 @@
   // Returns QUIC_NO_ERROR if this is the case or returns the appropriate error
   // code and sets |error_details|.
   static QuicErrorCode ValidateClientHello(
-      const CryptoHandshakeMessage& client_hello,
-      ParsedQuicVersion version,
+      const CryptoHandshakeMessage& client_hello, ParsedQuicVersion version,
       const ParsedQuicVersionVector& supported_versions,
       std::string* error_details);
 
@@ -212,8 +208,7 @@
   // Returns QUIC_NO_ERROR if this is the case or returns the appropriate error
   // code and sets |error_details|.
   static QuicErrorCode ValidateClientHelloVersion(
-      QuicVersionLabel client_version,
-      ParsedQuicVersion connection_version,
+      QuicVersionLabel client_version, ParsedQuicVersion connection_version,
       const ParsedQuicVersionVector& supported_versions,
       std::string* error_details);
 
diff --git a/quic/core/crypto/crypto_utils_test.cc b/quic/core/crypto/crypto_utils_test.cc
index 251f136..df1546a 100644
--- a/quic/core/crypto/crypto_utils_test.cc
+++ b/quic/core/crypto/crypto_utils_test.cc
@@ -8,6 +8,7 @@
 
 #include "absl/base/macros.h"
 #include "absl/strings/escaping.h"
+#include "absl/strings/string_view.h"
 #include "quic/core/quic_utils.h"
 #include "quic/platform/api/quic_test.h"
 #include "quic/test_tools/quic_test_utils.h"
@@ -165,6 +166,48 @@
   EXPECT_FALSE(error_details.empty());
 }
 
+// Test that the library is using the correct labels for each version, and
+// therefore generating correct obfuscators, using the test vectors in appendix
+// A of each RFC or internet-draft.
+TEST_F(CryptoUtilsTest, ValidateCryptoLabels) {
+  // if the number of HTTP/3 QUIC versions has changed, we need to change the
+  // expected_keys hardcoded into this test. Regrettably, this is not a
+  // compile-time constant.
+  EXPECT_EQ(AllSupportedVersionsWithTls().size(), 3u);
+  const char draft_29_key[] = {// test vector from draft-ietf-quic-tls-29, A.1
+                               0x14, 0x9d, 0x0b, 0x16, 0x62, 0xab, 0x87, 0x1f,
+                               0xbe, 0x63, 0xc4, 0x9b, 0x5e, 0x65, 0x5a, 0x5d};
+  const char v1_key[] = {// test vector from RFC 9001, A.1
+                         0xcf, 0x3a, 0x53, 0x31, 0x65, 0x3c, 0x36, 0x4c,
+                         0x88, 0xf0, 0xf3, 0x79, 0xb6, 0x06, 0x7e, 0x37};
+  const char v2_01_key[] = {// test vector from draft-ietf-quic-v2-01
+                            0x15, 0xd5, 0xb4, 0xd9, 0xa2, 0xb8, 0x91, 0x6a,
+                            0xa3, 0x9b, 0x1b, 0xfe, 0x57, 0x4d, 0x2a, 0xad};
+  const char connection_id[] =  // test vector from both docs
+      {0x83, 0x94, 0xc8, 0xf0, 0x3e, 0x51, 0x57, 0x08};
+  const QuicConnectionId cid(connection_id, sizeof(connection_id));
+  const char* key_str;
+  size_t key_size;
+  for (const ParsedQuicVersion& version : AllSupportedVersionsWithTls()) {
+    if (version == ParsedQuicVersion::Draft29()) {
+      key_str = draft_29_key;
+      key_size = sizeof(draft_29_key);
+    } else if (version == ParsedQuicVersion::RFCv1()) {
+      key_str = v1_key;
+      key_size = sizeof(v1_key);
+    } else {  // draft-ietf-quic-v2-01
+      key_str = v2_01_key;
+      key_size = sizeof(v2_01_key);
+    }
+    const absl::string_view expected_key{key_str, key_size};
+
+    CrypterPair crypters;
+    CryptoUtils::CreateInitialObfuscators(Perspective::IS_SERVER, version, cid,
+                                          &crypters);
+    EXPECT_EQ(crypters.encrypter->GetKey(), expected_key);
+  }
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace quic
diff --git a/quic/core/handshaker_delegate_interface.h b/quic/core/handshaker_delegate_interface.h
index 1e47d16..7fbc5ae 100644
--- a/quic/core/handshaker_delegate_interface.h
+++ b/quic/core/handshaker_delegate_interface.h
@@ -7,6 +7,7 @@
 
 #include "quic/core/crypto/transport_parameters.h"
 #include "quic/core/quic_types.h"
+#include "quic/core/quic_versions.h"
 
 namespace quic {
 
@@ -21,15 +22,12 @@
   // Called when new decryption key of |level| is available. Returns true if
   // decrypter is set successfully, otherwise, returns false.
   virtual bool OnNewDecryptionKeyAvailable(
-      EncryptionLevel level,
-      std::unique_ptr<QuicDecrypter> decrypter,
-      bool set_alternative_decrypter,
-      bool latch_once_used) = 0;
+      EncryptionLevel level, std::unique_ptr<QuicDecrypter> decrypter,
+      bool set_alternative_decrypter, bool latch_once_used) = 0;
 
   // Called when new encryption key of |level| is available.
   virtual void OnNewEncryptionKeyAvailable(
-      EncryptionLevel level,
-      std::unique_ptr<QuicEncrypter> encrypter) = 0;
+      EncryptionLevel level, std::unique_ptr<QuicEncrypter> encrypter) = 0;
 
   // Called to set default encryption level to |level|. Only used in QUIC
   // crypto.
@@ -68,8 +66,7 @@
   // On failure, returns a QuicErrorCode and saves a detailed error in
   // |error_details|.
   virtual QuicErrorCode ProcessTransportParameters(
-      const TransportParameters& params,
-      bool is_resumption,
+      const TransportParameters& params, bool is_resumption,
       std::string* error_details) = 0;
 
   // Called at the end of an handshake operation callback.
@@ -77,6 +74,10 @@
 
   // Whether a packet flusher is currently attached.
   virtual bool PacketFlusherAttached() const = 0;
+
+  // Get the QUIC version currently in use. tls_handshaker needs this to pass
+  // to crypto_utils to apply version-dependent HKDF labels.
+  virtual ParsedQuicVersion parsed_version() const = 0;
 };
 
 }  // namespace quic
diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index aa1ef09..cf84969 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -485,8 +485,7 @@
     }
   }
 
-  void AddToCache(absl::string_view path,
-                  int response_code,
+  void AddToCache(absl::string_view path, int response_code,
                   absl::string_view body) {
     memory_cache_backend_.AddSimpleResponse(server_hostname_, path,
                                             response_code, body);
@@ -657,16 +656,14 @@
   }
 
   bool SendSynchronousRequestAndCheckResponse(
-      QuicTestClient* client,
-      const std::string& request,
+      QuicTestClient* client, const std::string& request,
       const std::string& expected_response) {
     std::string received_response = client->SendSynchronousRequest(request);
     return CheckResponse(client, received_response, expected_response);
   }
 
   bool SendSynchronousRequestAndCheckResponse(
-      const std::string& request,
-      const std::string& expected_response) {
+      const std::string& request, const std::string& expected_response) {
     return SendSynchronousRequestAndCheckResponse(client_.get(), request,
                                                   expected_response);
   }
@@ -844,8 +841,7 @@
 };
 
 // Run all end to end tests with all supported versions.
-INSTANTIATE_TEST_SUITE_P(EndToEndTests,
-                         EndToEndTest,
+INSTANTIATE_TEST_SUITE_P(EndToEndTests, EndToEndTest,
                          ::testing::ValuesIn(GetTestParams()),
                          ::testing::PrintToStringParamName());
 
@@ -3210,8 +3206,7 @@
 class DuplicatePacketWithSpoofedSelfAddressWriter
     : public QuicPacketWriterWrapper {
  public:
-  WriteResult WritePacket(const char* buffer,
-                          size_t buf_len,
+  WriteResult WritePacket(const char* buffer, size_t buf_len,
                           const QuicIpAddress& self_address,
                           const QuicSocketAddress& peer_address,
                           PerPacketOptions* options) override {
@@ -4385,13 +4380,10 @@
 class ServerStreamWithErrorResponseBody : public QuicSimpleServerStream {
  public:
   ServerStreamWithErrorResponseBody(
-      QuicStreamId id,
-      QuicSpdySession* session,
+      QuicStreamId id, QuicSpdySession* session,
       QuicSimpleServerBackend* quic_simple_server_backend,
       std::string response_body)
-      : QuicSimpleServerStream(id,
-                               session,
-                               BIDIRECTIONAL,
+      : QuicSimpleServerStream(id, session, BIDIRECTIONAL,
                                quic_simple_server_backend),
         response_body_(std::move(response_body)) {}
 
@@ -4420,8 +4412,7 @@
   ~StreamWithErrorFactory() override = default;
 
   QuicSimpleServerStream* CreateStream(
-      QuicStreamId id,
-      QuicSpdySession* session,
+      QuicStreamId id, QuicSpdySession* session,
       QuicSimpleServerBackend* quic_simple_server_backend) override {
     return new ServerStreamWithErrorResponseBody(
         id, session, quic_simple_server_backend, response_body_);
@@ -4434,12 +4425,9 @@
 // A test server stream that drops all received body.
 class ServerStreamThatDropsBody : public QuicSimpleServerStream {
  public:
-  ServerStreamThatDropsBody(QuicStreamId id,
-                            QuicSpdySession* session,
+  ServerStreamThatDropsBody(QuicStreamId id, QuicSpdySession* session,
                             QuicSimpleServerBackend* quic_simple_server_backend)
-      : QuicSimpleServerStream(id,
-                               session,
-                               BIDIRECTIONAL,
+      : QuicSimpleServerStream(id, session, BIDIRECTIONAL,
                                quic_simple_server_backend) {}
 
   ~ServerStreamThatDropsBody() override = default;
@@ -4481,8 +4469,7 @@
   ~ServerStreamThatDropsBodyFactory() override = default;
 
   QuicSimpleServerStream* CreateStream(
-      QuicStreamId id,
-      QuicSpdySession* session,
+      QuicStreamId id, QuicSpdySession* session,
       QuicSimpleServerBackend* quic_simple_server_backend) override {
     return new ServerStreamThatDropsBody(id, session,
                                          quic_simple_server_backend);
@@ -4493,13 +4480,9 @@
 class ServerStreamThatSendsHugeResponse : public QuicSimpleServerStream {
  public:
   ServerStreamThatSendsHugeResponse(
-      QuicStreamId id,
-      QuicSpdySession* session,
-      QuicSimpleServerBackend* quic_simple_server_backend,
-      int64_t body_bytes)
-      : QuicSimpleServerStream(id,
-                               session,
-                               BIDIRECTIONAL,
+      QuicStreamId id, QuicSpdySession* session,
+      QuicSimpleServerBackend* quic_simple_server_backend, int64_t body_bytes)
+      : QuicSimpleServerStream(id, session, BIDIRECTIONAL,
                                quic_simple_server_backend),
         body_bytes_(body_bytes) {}
 
@@ -4529,8 +4512,7 @@
   ~ServerStreamThatSendsHugeResponseFactory() override = default;
 
   QuicSimpleServerStream* CreateStream(
-      QuicStreamId id,
-      QuicSpdySession* session,
+      QuicStreamId id, QuicSpdySession* session,
       QuicSimpleServerBackend* quic_simple_server_backend) override {
     return new ServerStreamThatSendsHugeResponse(
         id, session, quic_simple_server_backend, body_bytes_);
@@ -5255,8 +5237,7 @@
 // called.
 class PacketHoldingWriter : public QuicPacketWriterWrapper {
  public:
-  WriteResult WritePacket(const char* buffer,
-                          size_t buf_len,
+  WriteResult WritePacket(const char* buffer, size_t buf_len,
                           const QuicIpAddress& self_address,
                           const QuicSocketAddress& peer_address,
                           PerPacketOptions* options) override {
@@ -5710,8 +5691,7 @@
       : error_returned_(false), version_(version) {}
   ~BadShloPacketWriter() override {}
 
-  WriteResult WritePacket(const char* buffer,
-                          size_t buf_len,
+  WriteResult WritePacket(const char* buffer, size_t buf_len,
                           const QuicIpAddress& self_address,
                           const QuicSocketAddress& peer_address,
                           quic::PerPacketOptions* options) override {
@@ -5728,6 +5708,9 @@
   }
 
   bool TypeByteIsServerHello(uint8_t type_byte) {
+    if (version_.UsesV2PacketTypes()) {
+      return ((type_byte & 0x30) >> 4) == 3;
+    }
     if (version_.UsesQuicCrypto()) {
       // ENCRYPTION_ZERO_RTT packet.
       return ((type_byte & 0x30) >> 4) == 1;
@@ -5784,21 +5767,23 @@
 
 class BadShloPacketWriter2 : public QuicPacketWriterWrapper {
  public:
-  BadShloPacketWriter2() : error_returned_(false) {}
+  BadShloPacketWriter2(ParsedQuicVersion version)
+      : error_returned_(false), version_(version) {}
   ~BadShloPacketWriter2() override {}
 
-  WriteResult WritePacket(const char* buffer,
-                          size_t buf_len,
+  WriteResult WritePacket(const char* buffer, size_t buf_len,
                           const QuicIpAddress& self_address,
                           const QuicSocketAddress& peer_address,
                           quic::PerPacketOptions* options) override {
     const uint8_t type_byte = buffer[0];
-    if ((type_byte & FLAGS_LONG_HEADER) &&
-        (((type_byte & 0x30) >> 4) == 1 || (type_byte & 0x7F) == 0x7C)) {
-      QUIC_DVLOG(1) << "Dropping ZERO_RTT_PACKET packet";
-      return WriteResult(WRITE_STATUS_OK, buf_len);
-    }
-    if (!error_returned_ && !(type_byte & FLAGS_LONG_HEADER)) {
+
+    if (type_byte & FLAGS_LONG_HEADER) {
+      if (((type_byte & 0x30 >> 4) == (version_.UsesV2PacketTypes() ? 2 : 1)) ||
+          ((type_byte & 0x7F) == 0x7C)) {
+        QUIC_DVLOG(1) << "Dropping ZERO_RTT_PACKET packet";
+        return WriteResult(WRITE_STATUS_OK, buf_len);
+      }
+    } else if (!error_returned_) {
       QUIC_DVLOG(1) << "Return write error for short header packet";
       error_returned_ = true;
       return WriteResult(WRITE_STATUS_ERROR, QUIC_EMSGSIZE);
@@ -5809,6 +5794,7 @@
 
  private:
   bool error_returned_;
+  ParsedQuicVersion version_;
 };
 
 TEST_P(EndToEndTest, ForwardSecureConnectionClose) {
@@ -5839,7 +5825,7 @@
       dispatcher,
       // This causes the all server sent ZERO_RTT_PROTECTED packets to be
       // dropped, and first short header packet causes write error.
-      new BadShloPacketWriter2());
+      new BadShloPacketWriter2(version_));
   server_thread_->Resume();
   client_.reset(CreateQuicClient(client_writer_));
   EXPECT_EQ("", client_->SendSynchronousRequest("/foo"));
@@ -6028,8 +6014,7 @@
  public:
   explicit CopyingPacketWriter(int num_packets_to_copy)
       : num_packets_to_copy_(num_packets_to_copy) {}
-  WriteResult WritePacket(const char* buffer,
-                          size_t buf_len,
+  WriteResult WritePacket(const char* buffer, size_t buf_len,
                           const QuicIpAddress& self_address,
                           const QuicSocketAddress& peer_address,
                           PerPacketOptions* options) override {
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 393bfd8..053849f 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -184,19 +184,12 @@
   TestConnection(QuicConnectionId connection_id,
                  QuicSocketAddress initial_self_address,
                  QuicSocketAddress initial_peer_address,
-                 TestConnectionHelper* helper,
-                 TestAlarmFactory* alarm_factory,
-                 TestPacketWriter* writer,
-                 Perspective perspective,
+                 TestConnectionHelper* helper, TestAlarmFactory* alarm_factory,
+                 TestPacketWriter* writer, Perspective perspective,
                  ParsedQuicVersion version)
-      : QuicConnection(connection_id,
-                       initial_self_address,
-                       initial_peer_address,
-                       helper,
-                       alarm_factory,
-                       writer,
-                       /* owns_writer= */ false,
-                       perspective,
+      : QuicConnection(connection_id, initial_self_address,
+                       initial_peer_address, helper, alarm_factory, writer,
+                       /* owns_writer= */ false, perspective,
                        SupportedVersions(version)),
         notifier_(nullptr) {
     writer->set_perspective(perspective);
@@ -215,11 +208,9 @@
     QuicConnectionPeer::SetLossAlgorithm(this, loss_algorithm);
   }
 
-  void SendPacket(EncryptionLevel /*level*/,
-                  uint64_t packet_number,
+  void SendPacket(EncryptionLevel /*level*/, uint64_t packet_number,
                   std::unique_ptr<QuicPacket> packet,
-                  HasRetransmittableData retransmittable,
-                  bool has_ack,
+                  HasRetransmittableData retransmittable, bool has_ack,
                   bool has_pending_frames) {
     ScopedPacketFlusher flusher(this);
     char buffer[kMaxOutgoingPacketSize];
@@ -239,8 +230,7 @@
   }
 
   QuicConsumedData SaveAndSendStreamData(QuicStreamId id,
-                                         const struct iovec* iov,
-                                         int iov_count,
+                                         const struct iovec* iov, int iov_count,
                                          size_t total_length,
                                          QuicStreamOffset offset,
                                          StreamSendingState state) {
@@ -555,8 +545,7 @@
 
 // Run tests with combinations of {ParsedQuicVersion, AckResponse}.
 struct TestParams {
-  TestParams(ParsedQuicVersion version,
-             AckResponse ack_response,
+  TestParams(ParsedQuicVersion version, AckResponse ack_response,
              bool no_stop_waiting)
       : version(version),
         ack_response(ack_response),
@@ -609,30 +598,20 @@
  protected:
   QuicConnectionTest()
       : connection_id_(TestConnectionId()),
-        framer_(SupportedVersions(version()),
-                QuicTime::Zero(),
-                Perspective::IS_CLIENT,
-                connection_id_.length()),
+        framer_(SupportedVersions(version()), QuicTime::Zero(),
+                Perspective::IS_CLIENT, connection_id_.length()),
         send_algorithm_(new StrictMock<MockSendAlgorithm>),
         loss_algorithm_(new MockLossAlgorithm()),
         helper_(new TestConnectionHelper(&clock_, &random_generator_)),
         alarm_factory_(new TestAlarmFactory()),
-        peer_framer_(SupportedVersions(version()),
-                     QuicTime::Zero(),
-                     Perspective::IS_SERVER,
-                     connection_id_.length()),
-        peer_creator_(connection_id_,
-                      &peer_framer_,
+        peer_framer_(SupportedVersions(version()), QuicTime::Zero(),
+                     Perspective::IS_SERVER, connection_id_.length()),
+        peer_creator_(connection_id_, &peer_framer_,
                       /*delegate=*/nullptr),
         writer_(
             new TestPacketWriter(version(), &clock_, Perspective::IS_CLIENT)),
-        connection_(connection_id_,
-                    kSelfAddress,
-                    kPeerAddress,
-                    helper_.get(),
-                    alarm_factory_.get(),
-                    writer_.get(),
-                    Perspective::IS_CLIENT,
+        connection_(connection_id_, kSelfAddress, kPeerAddress, helper_.get(),
+                    alarm_factory_.get(), writer_.get(), Perspective::IS_CLIENT,
                     version()),
         creator_(QuicConnectionPeer::GetPacketCreator(&connection_)),
         manager_(QuicConnectionPeer::GetSentPacketManager(&connection_)),
@@ -872,16 +851,14 @@
         QuicReceivedPacket(encrypted_buffer, encrypted_length, clock_.Now()));
   }
 
-  size_t ProcessFramePacketAtLevel(uint64_t number,
-                                   QuicFrame frame,
+  size_t ProcessFramePacketAtLevel(uint64_t number, QuicFrame frame,
                                    EncryptionLevel level) {
     QuicFrames frames;
     frames.push_back(frame);
     return ProcessFramesPacketAtLevel(number, frames, level);
   }
 
-  size_t ProcessFramesPacketAtLevel(uint64_t number,
-                                    const QuicFrames& frames,
+  size_t ProcessFramesPacketAtLevel(uint64_t number, const QuicFrames& frames,
                                     EncryptionLevel level) {
     QuicPacketHeader header = ConstructPacketHeader(number, level);
     // Set the correct encryption level and encrypter on peer_creator and
@@ -1025,8 +1002,7 @@
     return encrypted_length;
   }
 
-  size_t ProcessDataPacketAtLevel(uint64_t number,
-                                  bool has_stop_waiting,
+  size_t ProcessDataPacketAtLevel(uint64_t number, bool has_stop_waiting,
                                   EncryptionLevel level) {
     std::unique_ptr<QuicPacket> packet(
         ConstructDataPacket(number, has_stop_waiting, level));
@@ -1055,8 +1031,7 @@
         QuicReceivedPacket(buffer, encrypted_length, QuicTime::Zero(), false));
   }
 
-  QuicByteCount SendStreamDataToPeer(QuicStreamId id,
-                                     absl::string_view data,
+  QuicByteCount SendStreamDataToPeer(QuicStreamId id, absl::string_view data,
                                      QuicStreamOffset offset,
                                      StreamSendingState state,
                                      QuicPacketNumber* last_packet) {
@@ -1084,8 +1059,7 @@
         .Times(AnyNumber());
   }
 
-  void SendRstStream(QuicStreamId id,
-                     QuicRstStreamErrorCode error,
+  void SendRstStream(QuicStreamId id, QuicRstStreamErrorCode error,
                      QuicStreamOffset bytes_written) {
     notifier_.WriteOrBufferRstStream(id, error, bytes_written);
     connection_.OnStreamReset(id, error);
@@ -10499,7 +10473,12 @@
     return;
   }
 
-  // These values come from draft-ietf-quic-tls Appendix A.4.
+  // These values come from draft-ietf-quic-v2 Appendix A.4.
+  uint8_t retry_packet_rfcv2[] = {
+      0xcf, 0x70, 0x9a, 0x50, 0xc4, 0x00, 0x08, 0xf0, 0x67, 0xa5, 0x50, 0x2a,
+      0x42, 0x62, 0xb5, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x1d, 0xc7, 0x11, 0x30,
+      0xcd, 0x1e, 0xd3, 0x9d, 0x6e, 0xfc, 0xee, 0x5c, 0x85, 0x80, 0x65, 0x01};
+  // These values come from RFC9001 Appendix A.4.
   uint8_t retry_packet_rfcv1[] = {
       0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0xf0, 0x67, 0xa5, 0x50, 0x2a,
       0x42, 0x62, 0xb5, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x04, 0xa2, 0x65, 0xba,
@@ -10511,7 +10490,10 @@
 
   uint8_t* retry_packet;
   size_t retry_packet_length;
-  if (version() == ParsedQuicVersion::RFCv1()) {
+  if (version() == ParsedQuicVersion::V2Draft01()) {
+    retry_packet = retry_packet_rfcv2;
+    retry_packet_length = ABSL_ARRAYSIZE(retry_packet_rfcv2);
+  } else if (version() == ParsedQuicVersion::RFCv1()) {
     retry_packet = retry_packet_rfcv1;
     retry_packet_length = ABSL_ARRAYSIZE(retry_packet_rfcv1);
   } else if (version() == ParsedQuicVersion::Draft29()) {
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index ca4ae48..add5164 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -1521,7 +1521,7 @@
   dispatcher_->ProcessPacket(server_address_, client_address, received_packet);
 }
 
-static_assert(quic::SupportedVersions().size() == 5u,
+static_assert(quic::SupportedVersions().size() == 6u,
               "Please add new RejectDeprecatedVersion tests above this assert "
               "when deprecating versions");
 
diff --git a/quic/core/quic_flags_list.h b/quic/core/quic_flags_list.h
index 7482050..90e3fbd 100644
--- a/quic/core/quic_flags_list.h
+++ b/quic/core/quic_flags_list.h
@@ -135,6 +135,8 @@
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_fix_pacing_sender_bursts, false)
 // When true, set the initial congestion control window from connection options in QuicSentPacketManager rather than TcpCubicSenderBytes.
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_unified_iw_options, true)
+// When true, support draft-ietf-quic-v2-01
+QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_enable_version_2_draft_01, false)
 // When true, the B203 connection option causes the Bbr2Sender to ignore inflight_hi during PROBE_UP and increase it when the bytes delivered without loss are higher.
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_bbr2_ignore_inflight_hi_in_probe_up, true)
 // When true, the B205 connection option enables extra acked in STARTUP, and B204 adds new logic to decrease it whenever max bandwidth increases.
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 79ace5a..6d2d9c7 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -170,8 +170,7 @@
   }
 }
 
-QuicPacketNumberLength ReadAckPacketNumberLength(
-    uint8_t flags) {
+QuicPacketNumberLength ReadAckPacketNumberLength(uint8_t flags) {
   switch (flags & PACKET_FLAGS_8BYTE_PACKET) {
     case PACKET_FLAGS_8BYTE_PACKET:
       return PACKET_6BYTE_PACKET_NUMBER;
@@ -197,16 +196,17 @@
   return static_cast<QuicPacketNumberLength>((type & 0x03) + 1);
 }
 
-uint8_t LongHeaderTypeToOnWireValue(QuicLongHeaderType type) {
+uint8_t LongHeaderTypeToOnWireValue(QuicLongHeaderType type,
+                                    const ParsedQuicVersion& version) {
   switch (type) {
     case INITIAL:
-      return 0;
+      return version.UsesV2PacketTypes() ? (1 << 4) : 0;
     case ZERO_RTT_PROTECTED:
-      return 1 << 4;
+      return version.UsesV2PacketTypes() ? (2 << 4) : (1 << 4);
     case HANDSHAKE:
-      return 2 << 4;
+      return version.UsesV2PacketTypes() ? (3 << 4) : (2 << 4);
     case RETRY:
-      return 3 << 4;
+      return version.UsesV2PacketTypes() ? 0 : (3 << 4);
     case VERSION_NEGOTIATION:
       return 0xF0;  // Value does not matter
     default:
@@ -215,20 +215,23 @@
   }
 }
 
-bool GetLongHeaderType(uint8_t type, QuicLongHeaderType* long_header_type) {
+bool GetLongHeaderType(uint8_t type, const ParsedQuicVersion& version,
+                       QuicLongHeaderType* long_header_type) {
   QUICHE_DCHECK((type & FLAGS_LONG_HEADER));
   switch ((type & 0x30) >> 4) {
     case 0:
-      *long_header_type = INITIAL;
+      *long_header_type = version.UsesV2PacketTypes() ? RETRY : INITIAL;
       break;
     case 1:
-      *long_header_type = ZERO_RTT_PROTECTED;
+      *long_header_type =
+          version.UsesV2PacketTypes() ? INITIAL : ZERO_RTT_PROTECTED;
       break;
     case 2:
-      *long_header_type = HANDSHAKE;
+      *long_header_type =
+          version.UsesV2PacketTypes() ? ZERO_RTT_PROTECTED : HANDSHAKE;
       break;
     case 3:
-      *long_header_type = RETRY;
+      *long_header_type = version.UsesV2PacketTypes() ? HANDSHAKE : RETRY;
       break;
     default:
       QUIC_BUG(quic_bug_10850_4) << "Unreachable statement";
@@ -331,8 +334,7 @@
   return full_packet_number > 0 || version.HasIetfQuicFrames();
 }
 
-bool AppendIetfConnectionIds(bool version_flag,
-                             bool use_length_prefix,
+bool AppendIetfConnectionIds(bool version_flag, bool use_length_prefix,
                              QuicConnectionId destination_connection_id,
                              QuicConnectionId source_connection_id,
                              QuicDataWriter* writer) {
@@ -533,8 +535,7 @@
 
 // static
 size_t QuicFramer::GetConnectionCloseFrameSize(
-    QuicTransportVersion version,
-    const QuicConnectionCloseFrame& frame) {
+    QuicTransportVersion version, const QuicConnectionCloseFrame& frame) {
   if (!VersionHasIetfQuicFrames(version)) {
     // Not IETF QUIC, return Google QUIC CONNECTION CLOSE frame size.
     return kQuicFrameTypeSize + kQuicErrorCodeSize +
@@ -569,8 +570,7 @@
 
 // static
 size_t QuicFramer::GetWindowUpdateFrameSize(
-    QuicTransportVersion version,
-    const QuicWindowUpdateFrame& frame) {
+    QuicTransportVersion version, const QuicWindowUpdateFrame& frame) {
   if (!VersionHasIetfQuicFrames(version)) {
     return kQuicFrameTypeSize + kQuicMaxStreamIdSize + kQuicMaxStreamOffsetSize;
   }
@@ -599,8 +599,7 @@
 
 // static
 size_t QuicFramer::GetStreamsBlockedFrameSize(
-    QuicTransportVersion version,
-    const QuicStreamsBlockedFrame& frame) {
+    QuicTransportVersion version, const QuicStreamsBlockedFrame& frame) {
   if (!VersionHasIetfQuicFrames(version)) {
     QUIC_BUG(quic_bug_10850_10)
         << "In version " << version
@@ -658,8 +657,7 @@
 
 // static
 size_t QuicFramer::GetRetransmittableControlFrameSize(
-    QuicTransportVersion version,
-    const QuicFrame& frame) {
+    QuicTransportVersion version, const QuicFrame& frame) {
   switch (frame.type) {
     case PING_FRAME:
       // Ping has no payload.
@@ -793,11 +791,8 @@
 }
 
 size_t QuicFramer::GetSerializedFrameLength(
-    const QuicFrame& frame,
-    size_t free_bytes,
-    bool first_frame,
-    bool last_frame,
-    QuicPacketNumberLength packet_number_length) {
+    const QuicFrame& frame, size_t free_bytes, bool first_frame,
+    bool last_frame, QuicPacketNumberLength packet_number_length) {
   // Prevent a rare crash reported in b/19458523.
   if (frame.type == ACK_FRAME && frame.ack_frame == nullptr) {
     QUIC_BUG(quic_bug_10850_13)
@@ -887,8 +882,7 @@
 }
 
 size_t QuicFramer::BuildDataPacket(const QuicPacketHeader& header,
-                                   const QuicFrames& frames,
-                                   char* buffer,
+                                   const QuicFrames& frames, char* buffer,
                                    size_t packet_length,
                                    EncryptionLevel level) {
   QUIC_BUG_IF(quic_bug_12975_2,
@@ -1345,10 +1339,8 @@
 // static
 std::unique_ptr<QuicEncryptedPacket> QuicFramer::BuildVersionNegotiationPacket(
     QuicConnectionId server_connection_id,
-    QuicConnectionId client_connection_id,
-    bool ietf_quic,
-    bool use_length_prefix,
-    const ParsedQuicVersionVector& versions) {
+    QuicConnectionId client_connection_id, bool ietf_quic,
+    bool use_length_prefix, const ParsedQuicVersionVector& versions) {
   QUIC_CODE_COUNT(quic_build_version_negotiation);
   if (use_length_prefix) {
     QUICHE_DCHECK(ietf_quic);
@@ -1420,8 +1412,7 @@
 // static
 std::unique_ptr<QuicEncryptedPacket>
 QuicFramer::BuildIetfVersionNegotiationPacket(
-    bool use_length_prefix,
-    QuicConnectionId server_connection_id,
+    bool use_length_prefix, QuicConnectionId server_connection_id,
     QuicConnectionId client_connection_id,
     const ParsedQuicVersionVector& versions) {
   QUIC_DVLOG(1) << "Building IETF version negotiation packet with"
@@ -1566,8 +1557,7 @@
 }
 
 bool QuicFramer::ProcessVersionNegotiationPacket(
-    QuicDataReader* reader,
-    const QuicPacketHeader& header) {
+    QuicDataReader* reader, const QuicPacketHeader& header) {
   QUICHE_DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
 
   QuicVersionNegotiationPacket packet(
@@ -1667,8 +1657,7 @@
 // If the IETF length field only spans part of the outer packet,
 // then there is a coalesced packet after this one.
 void QuicFramer::MaybeProcessCoalescedPacket(
-    const QuicDataReader& encrypted_reader,
-    uint64_t remaining_bytes_length,
+    const QuicDataReader& encrypted_reader, uint64_t remaining_bytes_length,
     const QuicPacketHeader& header) {
   if (header.remaining_packet_length >= remaining_bytes_length) {
     // There is no coalesced packet.
@@ -2221,7 +2210,7 @@
   if (header.version_flag) {
     type = static_cast<uint8_t>(
         FLAGS_LONG_HEADER | FLAGS_FIXED_BIT |
-        LongHeaderTypeToOnWireValue(header.long_packet_type) |
+        LongHeaderTypeToOnWireValue(header.long_packet_type, version_) |
         PacketNumberLengthToOnWireValue(header.packet_number_length));
   } else {
     type = static_cast<uint8_t>(
@@ -2357,8 +2346,7 @@
 
 uint64_t QuicFramer::CalculatePacketNumberFromWire(
     QuicPacketNumberLength packet_number_length,
-    QuicPacketNumber base_packet_number,
-    uint64_t packet_number) const {
+    QuicPacketNumber base_packet_number, uint64_t packet_number) const {
   // The new packet number might have wrapped to the next epoch, or
   // it might have reverse wrapped to the previous epoch, or it might
   // remain in the same epoch.  Select the packet number closest to the
@@ -2632,7 +2620,8 @@
           set_detailed_error("Fixed bit is 0 in long header.");
           return false;
         }
-        if (!GetLongHeaderType(type, &header->long_packet_type)) {
+        if (!GetLongHeaderType(type, header->version,
+                               &header->long_packet_type)) {
           set_detailed_error("Illegal long header type value.");
           return false;
         }
@@ -2690,14 +2679,11 @@
 
 // static
 bool QuicFramer::ProcessAndValidateIetfConnectionIdLength(
-    QuicDataReader* reader,
-    ParsedQuicVersion version,
-    Perspective perspective,
+    QuicDataReader* reader, ParsedQuicVersion version, Perspective perspective,
     bool should_update_expected_server_connection_id_length,
     uint8_t* expected_server_connection_id_length,
     uint8_t* destination_connection_id_length,
-    uint8_t* source_connection_id_length,
-    std::string* detailed_error) {
+    uint8_t* source_connection_id_length, std::string* detailed_error) {
   uint8_t connection_id_lengths_byte;
   if (!reader->ReadBytes(&connection_id_lengths_byte, 1)) {
     *detailed_error = "Unable to read ConnectionId length.";
@@ -2880,10 +2866,8 @@
 }
 
 bool QuicFramer::ProcessAndCalculatePacketNumber(
-    QuicDataReader* reader,
-    QuicPacketNumberLength packet_number_length,
-    QuicPacketNumber base_packet_number,
-    uint64_t* packet_number) {
+    QuicDataReader* reader, QuicPacketNumberLength packet_number_length,
+    QuicPacketNumber base_packet_number, uint64_t* packet_number) {
   uint64_t wire_packet_number;
   if (!reader->ReadBytesToUInt64(packet_number_length, &wire_packet_number)) {
     return false;
@@ -3131,8 +3115,7 @@
 
 // static
 bool QuicFramer::IsIetfFrameTypeExpectedForEncryptionLevel(
-    uint64_t frame_type,
-    EncryptionLevel level) {
+    uint64_t frame_type, EncryptionLevel level) {
   switch (level) {
     case ENCRYPTION_INITIAL:
     case ENCRYPTION_HANDSHAKE:
@@ -3560,8 +3543,7 @@
 }
 }  // namespace
 
-bool QuicFramer::ProcessStreamFrame(QuicDataReader* reader,
-                                    uint8_t frame_type,
+bool QuicFramer::ProcessStreamFrame(QuicDataReader* reader, uint8_t frame_type,
                                     QuicStreamFrame* frame) {
   uint8_t stream_flags = frame_type;
 
@@ -3748,12 +3730,12 @@
 
   // Determine the two lengths from the frame type: largest acked length,
   // ack block length.
-  const QuicPacketNumberLength ack_block_length = ReadAckPacketNumberLength(
-      ExtractBits(frame_type, kQuicSequenceNumberLengthNumBits,
-                  kActBlockLengthOffset));
-  const QuicPacketNumberLength largest_acked_length = ReadAckPacketNumberLength(
-      ExtractBits(frame_type, kQuicSequenceNumberLengthNumBits,
-                  kLargestAckedOffset));
+  const QuicPacketNumberLength ack_block_length =
+      ReadAckPacketNumberLength(ExtractBits(
+          frame_type, kQuicSequenceNumberLengthNumBits, kActBlockLengthOffset));
+  const QuicPacketNumberLength largest_acked_length =
+      ReadAckPacketNumberLength(ExtractBits(
+          frame_type, kQuicSequenceNumberLengthNumBits, kLargestAckedOffset));
 
   uint64_t largest_acked;
   if (!reader->ReadBytesToUInt64(largest_acked_length, &largest_acked)) {
@@ -4364,11 +4346,9 @@
 
 // static
 absl::string_view QuicFramer::GetAssociatedDataFromEncryptedPacket(
-    QuicTransportVersion version,
-    const QuicEncryptedPacket& encrypted,
+    QuicTransportVersion version, const QuicEncryptedPacket& encrypted,
     QuicConnectionIdLength destination_connection_id_length,
-    QuicConnectionIdLength source_connection_id_length,
-    bool includes_version,
+    QuicConnectionIdLength source_connection_id_length, bool includes_version,
     bool includes_diversification_nonce,
     QuicPacketNumberLength packet_number_length,
     QuicVariableLengthIntegerLength retry_token_length_length,
@@ -4397,8 +4377,7 @@
 }
 
 void QuicFramer::SetAlternativeDecrypter(
-    EncryptionLevel level,
-    std::unique_ptr<QuicDecrypter> decrypter,
+    EncryptionLevel level, std::unique_ptr<QuicDecrypter> decrypter,
     bool latch_once_used) {
   QUICHE_DCHECK_NE(level, decrypter_level_);
   QUICHE_DCHECK(!version_.KnowsWhichDecrypterToUse());
@@ -4523,10 +4502,8 @@
 }
 
 size_t QuicFramer::EncryptInPlace(EncryptionLevel level,
-                                  QuicPacketNumber packet_number,
-                                  size_t ad_len,
-                                  size_t total_len,
-                                  size_t buffer_len,
+                                  QuicPacketNumber packet_number, size_t ad_len,
+                                  size_t total_len, size_t buffer_len,
                                   char* buffer) {
   QUICHE_DCHECK(packet_number.IsInitialized());
   if (encrypter_[level] == nullptr) {
@@ -4568,10 +4545,8 @@
 
 }  // namespace
 
-bool QuicFramer::ApplyHeaderProtection(EncryptionLevel level,
-                                       char* buffer,
-                                       size_t buffer_len,
-                                       size_t ad_len) {
+bool QuicFramer::ApplyHeaderProtection(EncryptionLevel level, char* buffer,
+                                       size_t buffer_len, size_t ad_len) {
   QuicDataReader buffer_reader(buffer, buffer_len);
   QuicDataWriter buffer_writer(buffer_len, buffer);
   // The sample starts 4 bytes after the start of the packet number.
@@ -4615,7 +4590,7 @@
   QuicLongHeaderType header_type;
   if (IsLongHeader(type_byte)) {
     bitmask = 0x0f;
-    if (!GetLongHeaderType(type_byte, &header_type)) {
+    if (!GetLongHeaderType(type_byte, version_, &header_type)) {
       return false;
     }
   }
@@ -4781,8 +4756,7 @@
 
 size_t QuicFramer::EncryptPayload(EncryptionLevel level,
                                   QuicPacketNumber packet_number,
-                                  const QuicPacket& packet,
-                                  char* buffer,
+                                  const QuicPacket& packet, char* buffer,
                                   size_t buffer_len) {
   QUICHE_DCHECK(packet_number.IsInitialized());
   if (encrypter_[level] == nullptr) {
@@ -4867,8 +4841,7 @@
                                 absl::string_view encrypted,
                                 absl::string_view associated_data,
                                 const QuicPacketHeader& header,
-                                char* decrypted_buffer,
-                                size_t buffer_length,
+                                char* decrypted_buffer, size_t buffer_length,
                                 size_t* decrypted_length,
                                 EncryptionLevel* decrypted_level) {
   if (!EncryptionLevelIsValid(decrypter_level_)) {
@@ -5100,8 +5073,7 @@
 }
 
 size_t QuicFramer::GetAckFrameSize(
-    const QuicAckFrame& ack,
-    QuicPacketNumberLength /*packet_number_length*/) {
+    const QuicAckFrame& ack, QuicPacketNumberLength /*packet_number_length*/) {
   QUICHE_DCHECK(!ack.packets.Empty());
   size_t ack_size = 0;
 
@@ -5141,8 +5113,7 @@
 }
 
 size_t QuicFramer::ComputeFrameLength(
-    const QuicFrame& frame,
-    bool last_frame_in_packet,
+    const QuicFrame& frame, bool last_frame_in_packet,
     QuicPacketNumberLength packet_number_length) {
   switch (frame.type) {
     case STREAM_FRAME:
@@ -5370,8 +5341,7 @@
 }
 
 // static
-bool QuicFramer::AppendStreamId(size_t stream_id_length,
-                                QuicStreamId stream_id,
+bool QuicFramer::AppendStreamId(size_t stream_id_length, QuicStreamId stream_id,
                                 QuicDataWriter* writer) {
   if (stream_id_length == 0 || stream_id_length > 4) {
     QUIC_BUG(quic_bug_10850_77)
@@ -5397,8 +5367,7 @@
 // static
 bool QuicFramer::AppendAckBlock(uint8_t gap,
                                 QuicPacketNumberLength length_length,
-                                uint64_t length,
-                                QuicDataWriter* writer) {
+                                uint64_t length, QuicDataWriter* writer) {
   if (length == 0) {
     if (!IsValidPacketNumberLength(length_length)) {
       QUIC_BUG(quic_bug_10850_79)
@@ -5976,8 +5945,7 @@
 }
 
 bool QuicFramer::AppendConnectionCloseFrame(
-    const QuicConnectionCloseFrame& frame,
-    QuicDataWriter* writer) {
+    const QuicConnectionCloseFrame& frame, QuicDataWriter* writer) {
   if (VersionHasIetfQuicFrames(version_.transport_version)) {
     return AppendIetfConnectionCloseFrame(frame, writer);
   }
@@ -6084,8 +6052,7 @@
 }
 
 bool QuicFramer::IsVersionNegotiation(
-    const QuicPacketHeader& header,
-    bool packet_has_ietf_packet_header) const {
+    const QuicPacketHeader& header, bool packet_has_ietf_packet_header) const {
   if (!packet_has_ietf_packet_header &&
       perspective_ == Perspective::IS_CLIENT) {
     return header.version_flag;
@@ -6097,8 +6064,7 @@
 }
 
 bool QuicFramer::AppendIetfConnectionCloseFrame(
-    const QuicConnectionCloseFrame& frame,
-    QuicDataWriter* writer) {
+    const QuicConnectionCloseFrame& frame, QuicDataWriter* writer) {
   if (frame.close_type != IETF_QUIC_TRANSPORT_CONNECTION_CLOSE &&
       frame.close_type != IETF_QUIC_APPLICATION_CONNECTION_CLOSE) {
     QUIC_BUG(quic_bug_10850_90)
@@ -6135,8 +6101,7 @@
 }
 
 bool QuicFramer::ProcessIetfConnectionCloseFrame(
-    QuicDataReader* reader,
-    QuicConnectionCloseType type,
+    QuicDataReader* reader, QuicConnectionCloseType type,
     QuicConnectionCloseFrame* frame) {
   frame->close_type = type;
 
@@ -6263,8 +6228,7 @@
 }
 
 bool QuicFramer::ProcessStopSendingFrame(
-    QuicDataReader* reader,
-    QuicStopSendingFrame* stop_sending_frame) {
+    QuicDataReader* reader, QuicStopSendingFrame* stop_sending_frame) {
   if (!ReadUint32FromVarint62(reader, IETF_STOP_SENDING,
                               &stop_sending_frame->stream_id)) {
     return false;
@@ -6281,8 +6245,7 @@
 }
 
 bool QuicFramer::AppendStopSendingFrame(
-    const QuicStopSendingFrame& stop_sending_frame,
-    QuicDataWriter* writer) {
+    const QuicStopSendingFrame& stop_sending_frame, QuicDataWriter* writer) {
   if (!writer->WriteVarInt62(stop_sending_frame.stream_id)) {
     set_detailed_error("Can not write stop sending stream id");
     return false;
@@ -6438,8 +6401,7 @@
 }
 
 bool QuicFramer::AppendNewConnectionIdFrame(
-    const QuicNewConnectionIdFrame& frame,
-    QuicDataWriter* writer) {
+    const QuicNewConnectionIdFrame& frame, QuicDataWriter* writer) {
   if (!writer->WriteVarInt62(frame.sequence_number)) {
     set_detailed_error("Can not write New Connection ID sequence number");
     return false;
@@ -6500,8 +6462,7 @@
 }
 
 bool QuicFramer::AppendRetireConnectionIdFrame(
-    const QuicRetireConnectionIdFrame& frame,
-    QuicDataWriter* writer) {
+    const QuicRetireConnectionIdFrame& frame, QuicDataWriter* writer) {
   if (!writer->WriteVarInt62(frame.sequence_number)) {
     set_detailed_error("Can not write Retire Connection ID sequence number");
     return false;
@@ -6510,8 +6471,7 @@
 }
 
 bool QuicFramer::ProcessRetireConnectionIdFrame(
-    QuicDataReader* reader,
-    QuicRetireConnectionIdFrame* frame) {
+    QuicDataReader* reader, QuicRetireConnectionIdFrame* frame) {
   if (!reader->ReadVarInt62(&frame->sequence_number)) {
     set_detailed_error(
         "Unable to read retire connection ID frame sequence number.");
@@ -6567,8 +6527,7 @@
 }
 
 uint8_t QuicFramer::GetIetfStreamFrameTypeByte(
-    const QuicStreamFrame& frame,
-    bool last_frame_in_packet) const {
+    const QuicStreamFrame& frame, bool last_frame_in_packet) const {
   QUICHE_DCHECK(VersionHasIetfQuicFrames(version_.transport_version));
   uint8_t type_byte = IETF_STREAM;
   if (!last_frame_in_packet) {
@@ -6662,14 +6621,10 @@
 
 // static
 QuicErrorCode QuicFramer::ParsePublicHeaderGoogleQuic(
-    QuicDataReader* reader,
-    uint8_t* first_byte,
-    PacketHeaderFormat* format,
-    bool* version_present,
-    QuicVersionLabel* version_label,
+    QuicDataReader* reader, uint8_t* first_byte, PacketHeaderFormat* format,
+    bool* version_present, QuicVersionLabel* version_label,
     ParsedQuicVersion* parsed_version,
-    QuicConnectionId* destination_connection_id,
-    std::string* detailed_error) {
+    QuicConnectionId* destination_connection_id, std::string* detailed_error) {
   *format = GOOGLE_QUIC_PACKET;
   *version_present = (*first_byte & PACKET_PUBLIC_FLAGS_VERSION) != 0;
   uint8_t destination_connection_id_length = 0;
@@ -6696,10 +6651,8 @@
 const QuicVersionLabel kProxVersionLabel = 0x50524F58;  // "PROX"
 
 inline bool PacketHasLengthPrefixedConnectionIds(
-    const QuicDataReader& reader,
-    ParsedQuicVersion parsed_version,
-    QuicVersionLabel version_label,
-    uint8_t first_byte) {
+    const QuicDataReader& reader, ParsedQuicVersion parsed_version,
+    QuicVersionLabel version_label, uint8_t first_byte) {
   if (parsed_version.IsKnown()) {
     return parsed_version.HasLengthPrefixedConnectionIds();
   }
@@ -6733,12 +6686,9 @@
 }
 
 inline bool ParseLongHeaderConnectionIds(
-    QuicDataReader* reader,
-    bool has_length_prefix,
-    QuicVersionLabel version_label,
-    QuicConnectionId* destination_connection_id,
-    QuicConnectionId* source_connection_id,
-    std::string* detailed_error) {
+    QuicDataReader* reader, bool has_length_prefix,
+    QuicVersionLabel version_label, QuicConnectionId* destination_connection_id,
+    QuicConnectionId* source_connection_id, std::string* detailed_error) {
   if (has_length_prefix) {
     if (!reader->ReadLengthPrefixedConnectionId(destination_connection_id)) {
       *detailed_error = "Unable to read destination connection ID.";
@@ -6795,21 +6745,15 @@
 
 // static
 QuicErrorCode QuicFramer::ParsePublicHeader(
-    QuicDataReader* reader,
-    uint8_t expected_destination_connection_id_length,
-    bool ietf_format,
-    uint8_t* first_byte,
-    PacketHeaderFormat* format,
-    bool* version_present,
-    bool* has_length_prefix,
-    QuicVersionLabel* version_label,
-    ParsedQuicVersion* parsed_version,
+    QuicDataReader* reader, uint8_t expected_destination_connection_id_length,
+    bool ietf_format, uint8_t* first_byte, PacketHeaderFormat* format,
+    bool* version_present, bool* has_length_prefix,
+    QuicVersionLabel* version_label, ParsedQuicVersion* parsed_version,
     QuicConnectionId* destination_connection_id,
     QuicConnectionId* source_connection_id,
     QuicLongHeaderType* long_packet_type,
     QuicVariableLengthIntegerLength* retry_token_length_length,
-    absl::string_view* retry_token,
-    std::string* detailed_error) {
+    absl::string_view* retry_token, std::string* detailed_error) {
   *version_present = false;
   *has_length_prefix = false;
   *version_label = 0;
@@ -6875,7 +6819,7 @@
   }
 
   // Parse long packet type.
-  if (!GetLongHeaderType(*first_byte, long_packet_type)) {
+  if (!GetLongHeaderType(*first_byte, *parsed_version, long_packet_type)) {
     *detailed_error = "Unable to parse long packet type.";
     return QUIC_INVALID_PACKET_HEADER;
   }
@@ -6903,8 +6847,7 @@
 
 // static
 bool QuicFramer::WriteClientVersionNegotiationProbePacket(
-    char* packet_bytes,
-    QuicByteCount packet_length,
+    char* packet_bytes, QuicByteCount packet_length,
     const char* destination_connection_id_bytes,
     uint8_t destination_connection_id_length) {
   if (packet_bytes == nullptr) {
@@ -6981,10 +6924,8 @@
 
 // static
 bool QuicFramer::ParseServerVersionNegotiationProbeResponse(
-    const char* packet_bytes,
-    QuicByteCount packet_length,
-    char* source_connection_id_bytes,
-    uint8_t* source_connection_id_length_out,
+    const char* packet_bytes, QuicByteCount packet_length,
+    char* source_connection_id_bytes, uint8_t* source_connection_id_length_out,
     std::string* detailed_error) {
   if (detailed_error == nullptr) {
     QUIC_BUG(quic_bug_10850_101) << "Invalid error_details";
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index 28b7c20..207329c 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -105,10 +105,8 @@
   bool SetHeaderProtectionKey(absl::string_view /*key*/) override {
     return true;
   }
-  bool EncryptPacket(uint64_t packet_number,
-                     absl::string_view associated_data,
-                     absl::string_view plaintext,
-                     char* output,
+  bool EncryptPacket(uint64_t packet_number, absl::string_view associated_data,
+                     absl::string_view plaintext, char* output,
                      size_t* output_length,
                      size_t /*max_output_length*/) override {
     packet_number_ = QuicPacketNumber(packet_number);
@@ -162,10 +160,8 @@
   bool SetDiversificationNonce(const DiversificationNonce& /*key*/) override {
     return true;
   }
-  bool DecryptPacket(uint64_t packet_number,
-                     absl::string_view associated_data,
-                     absl::string_view ciphertext,
-                     char* output,
+  bool DecryptPacket(uint64_t packet_number, absl::string_view associated_data,
+                     absl::string_view ciphertext, char* output,
                      size_t* output_length,
                      size_t /*max_output_length*/) override {
     packet_number_ = QuicPacketNumber(packet_number);
@@ -197,9 +193,7 @@
 };
 
 std::unique_ptr<QuicEncryptedPacket> EncryptPacketWithTagAndPhase(
-    const QuicPacket& packet,
-    uint8_t tag,
-    bool phase) {
+    const QuicPacket& packet, uint8_t tag, bool phase) {
   std::string packet_data = std::string(packet.AsStringPiece());
   if (phase) {
     packet_data[0] |= FLAGS_KEY_PHASE_BIT;
@@ -692,9 +686,7 @@
         decrypter_(new test::TestDecrypter()),
         version_(GetParam()),
         start_(QuicTime::Zero() + QuicTime::Delta::FromMicroseconds(0x10)),
-        framer_(AllSupportedVersions(),
-                start_,
-                Perspective::IS_SERVER,
+        framer_(AllSupportedVersions(), start_, Perspective::IS_SERVER,
                 kQuicDefaultConnectionIdLength) {
     framer_.set_version(version_);
     if (framer_.version().KnowsWhichDecrypterToUse()) {
@@ -726,6 +718,19 @@
     return (CreateQuicVersionLabel(version_) >> 8 * (3 - pos)) & 0xff;
   }
 
+  // Helper functions to take a v1 long header packet and make it v2. These are
+  // not needed for short header packets, but if sent, this function will exit
+  // cleanly. It needs to be called twice for coalesced packets (see references
+  // to length_of_first_coalesced_packet below for examples of how to do this).
+  inline void ReviseFirstByteByVersion(unsigned char packet_ietf[]) {
+    if (version_.UsesV2PacketTypes() && (packet_ietf[0] >= 0x80)) {
+      packet_ietf[0] = (packet_ietf[0] + 0x10) | 0xc0;
+    }
+  }
+  inline void ReviseFirstByteByVersion(PacketFragments& packet_ietf) {
+    ReviseFirstByteByVersion(&packet_ietf[0].fragment[0]);
+  }
+
   bool CheckEncryption(QuicPacketNumber packet_number, QuicPacket* packet) {
     if (packet_number != encrypter_->packet_number_) {
       QUIC_LOG(ERROR) << "Encrypted incorrect packet number.  expected "
@@ -762,8 +767,7 @@
   }
 
   bool CheckDecryption(
-      const QuicEncryptedPacket& encrypted,
-      bool includes_version,
+      const QuicEncryptedPacket& encrypted, bool includes_version,
       bool includes_diversification_nonce,
       QuicConnectionIdLength destination_connection_id_length,
       QuicConnectionIdLength source_connection_id_length,
@@ -838,15 +842,13 @@
         }
       }
 
-      if (expected_error.empty())
-        continue;
+      if (expected_error.empty()) continue;
 
       CheckProcessingFails(*packet, i, expected_error, error_code);
     }
   }
 
-  void CheckProcessingFails(const QuicEncryptedPacket& packet,
-                            size_t len,
+  void CheckProcessingFails(const QuicEncryptedPacket& packet, size_t len,
                             std::string expected_error,
                             QuicErrorCode error_code) {
     QuicEncryptedPacket encrypted(packet.data(), len, false);
@@ -855,8 +857,7 @@
     EXPECT_EQ(error_code, framer_.error()) << "len: " << len;
   }
 
-  void CheckProcessingFails(unsigned char* packet,
-                            size_t len,
+  void CheckProcessingFails(unsigned char* packet, size_t len,
                             std::string expected_error,
                             QuicErrorCode error_code) {
     QuicEncryptedPacket encrypted(AsChars(packet), len, false);
@@ -894,8 +895,7 @@
 
   // N starts at 1.
   QuicStreamId GetNthStreamid(QuicTransportVersion transport_version,
-                              Perspective perspective,
-                              bool bidirectional,
+                              Perspective perspective, bool bidirectional,
                               int n) {
     if (bidirectional) {
       return QuicUtils::GetFirstBidirectionalStreamId(transport_version,
@@ -931,8 +931,7 @@
       GetQuicVersionByte(3)
 
 // Run all framer tests with all supported versions of QUIC.
-INSTANTIATE_TEST_SUITE_P(QuicFramerTests,
-                         QuicFramerTest,
+INSTANTIATE_TEST_SUITE_P(QuicFramerTests, QuicFramerTest,
                          ::testing::ValuesIn(AllSupportedVersions()),
                          ::testing::PrintToStringParamName());
 
@@ -1273,6 +1272,7 @@
   unsigned char* p = packet;
   size_t p_length = ABSL_ARRAYSIZE(packet);
   if (framer_.version().HasLongHeaderLengths()) {
+    ReviseFirstByteByVersion(packet49);
     p = packet49;
     p_length = ABSL_ARRAYSIZE(packet49);
   }
@@ -1379,6 +1379,7 @@
   unsigned char* p = packet;
   size_t p_length = ABSL_ARRAYSIZE(packet);
   if (framer_.version().HasLongHeaderLengths()) {
+    ReviseFirstByteByVersion(packet49);
     p = packet49;
     p_length = ABSL_ARRAYSIZE(packet49);
   } else if (framer_.version().HasIetfInvariantHeader()) {
@@ -1669,6 +1670,7 @@
   };
   // clang-format on
 
+  ReviseFirstByteByVersion(packet49);
   PacketFragments& fragments =
       framer_.version().HasLongHeaderLengths()
           ? packet49
@@ -2970,6 +2972,7 @@
           ? VARIABLE_LENGTH_INTEGER_LENGTH_1
           : VARIABLE_LENGTH_INTEGER_LENGTH_0;
 
+  ReviseFirstByteByVersion(packet_ietf);
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet_ietf
@@ -6420,6 +6423,7 @@
   unsigned char* p = packet;
   size_t p_length = ABSL_ARRAYSIZE(packet);
   if (framer_.version().UsesTls()) {
+    ReviseFirstByteByVersion(packet_with_tag);
     p = packet_with_tag;
     p_length = ABSL_ARRAYSIZE(packet_with_tag);
   } else if (framer_.version().HasLongHeaderLengths()) {
@@ -7115,6 +7119,7 @@
   unsigned char* p = packet;
   size_t p_size = ABSL_ARRAYSIZE(packet);
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
+    ReviseFirstByteByVersion(packet_ietf);
     p = packet_ietf;
     p_size = ABSL_ARRAYSIZE(packet_ietf);
   } else if (framer_.version().HasLongHeaderLengths()) {
@@ -13034,10 +13039,16 @@
       'R',  'L',  'D',  '?',
   };
   // clang-format on
+  const size_t first_packet_ietf_size = 46;
+  // If the first packet changes, the attempt to fix the first byte of the
+  // second packet will fail.
+  EXPECT_EQ(packet_ietf[first_packet_ietf_size], 0xD3);
 
   unsigned char* p = packet;
   size_t p_length = ABSL_ARRAYSIZE(packet);
   if (framer_.version().HasIetfQuicFrames()) {
+    ReviseFirstByteByVersion(packet_ietf);
+    ReviseFirstByteByVersion(&packet_ietf[first_packet_ietf_size]);
     p = packet_ietf;
     p_length = ABSL_ARRAYSIZE(packet_ietf);
   }
@@ -13157,6 +13168,7 @@
   unsigned char* p = packet;
   size_t p_length = ABSL_ARRAYSIZE(packet);
   if (framer_.version().HasIetfQuicFrames()) {
+    ReviseFirstByteByVersion(packet_ietf);
     p = packet_ietf;
     p_length = ABSL_ARRAYSIZE(packet_ietf);
   }
@@ -13304,10 +13316,16 @@
       'R',  'L',  'D',  '?',
   };
   // clang-format on
+  const size_t first_packet_ietf_size = 46;
+  // If the first packet changes, the attempt to fix the first byte of the
+  // second packet will fail.
+  EXPECT_EQ(packet_ietf[first_packet_ietf_size], 0xD3);
 
   unsigned char* p = packet;
   size_t p_length = ABSL_ARRAYSIZE(packet);
   if (framer_.version().HasIetfQuicFrames()) {
+    ReviseFirstByteByVersion(packet_ietf);
+    ReviseFirstByteByVersion(&packet_ietf[first_packet_ietf_size]);
     p = packet_ietf;
     p_length = ABSL_ARRAYSIZE(packet_ietf);
   }
@@ -13415,6 +13433,7 @@
   unsigned char* p = packet;
   size_t p_length = ABSL_ARRAYSIZE(packet);
   if (framer_.version().HasLongHeaderLengths()) {
+    ReviseFirstByteByVersion(packet49);
     p = packet49;
     p_length = ABSL_ARRAYSIZE(packet49);
   } else if (framer_.version().HasIetfInvariantHeader()) {
@@ -13517,6 +13536,7 @@
   unsigned char* p = packet;
   size_t p_length = ABSL_ARRAYSIZE(packet);
   if (framer_.version().HasLongHeaderLengths()) {
+    ReviseFirstByteByVersion(packet49);
     p = packet49;
     p_length = ABSL_ARRAYSIZE(packet49);
   } else if (framer_.version().HasIetfInvariantHeader()) {
@@ -13677,10 +13697,15 @@
   };
   // clang-format on
   const size_t length_of_first_coalesced_packet = 46;
+  // If the first packet changes, the attempt to fix the first byte of the
+  // second packet will fail.
+  EXPECT_EQ(packet_ietf[length_of_first_coalesced_packet], 0xD3);
 
   unsigned char* p = packet;
   size_t p_length = ABSL_ARRAYSIZE(packet);
   if (framer_.version().HasIetfQuicFrames()) {
+    ReviseFirstByteByVersion(packet_ietf);
+    ReviseFirstByteByVersion(&packet_ietf[length_of_first_coalesced_packet]);
     p = packet_ietf;
     p_length = ABSL_ARRAYSIZE(packet_ietf);
   }
@@ -13844,10 +13869,16 @@
       'R',  'L',  'D',  '?',
   };
   // clang-format on
+  const size_t length_of_first_coalesced_packet = 46;
+  // If the first packet changes, the attempt to fix the first byte of the
+  // second packet will fail.
+  EXPECT_EQ(packet_ietf[length_of_first_coalesced_packet], 0xD3);
 
   unsigned char* p = packet;
   size_t p_length = ABSL_ARRAYSIZE(packet);
   if (framer_.version().HasIetfQuicFrames()) {
+    ReviseFirstByteByVersion(packet_ietf);
+    ReviseFirstByteByVersion(&packet_ietf[length_of_first_coalesced_packet]);
     p = packet_ietf;
     p_length = ABSL_ARRAYSIZE(packet_ietf);
   }
@@ -13949,10 +13980,16 @@
       // version would be here but we cut off the invalid coalesced header.
   };
   // clang-format on
+  const size_t length_of_first_coalesced_packet = 46;
+  // If the first packet changes, the attempt to fix the first byte of the
+  // second packet will fail.
+  EXPECT_EQ(packet_ietf[length_of_first_coalesced_packet], 0xD3);
 
   unsigned char* p = packet;
   size_t p_length = ABSL_ARRAYSIZE(packet);
   if (framer_.version().HasIetfQuicFrames()) {
+    ReviseFirstByteByVersion(packet_ietf);
+    ReviseFirstByteByVersion(&packet_ietf[length_of_first_coalesced_packet]);
     p = packet_ietf;
     p_length = ABSL_ARRAYSIZE(packet_ietf);
   }
@@ -14180,6 +14217,7 @@
         QuicEncryptedPacket(AsChars(long_header_packet),
                             ABSL_ARRAYSIZE(long_header_packet), false)));
   } else {
+    ReviseFirstByteByVersion(long_header_packet_ietf);
     EXPECT_TRUE(framer_.ProcessPacket(
         QuicEncryptedPacket(AsChars(long_header_packet_ietf),
                             ABSL_ARRAYSIZE(long_header_packet_ietf), false)));
@@ -14708,9 +14746,11 @@
     0x00,
   };
   // clang-format on
+
   unsigned char* p = packet;
   size_t p_length = ABSL_ARRAYSIZE(packet);
   if (framer_.version().HasLongHeaderLengths()) {
+    ReviseFirstByteByVersion(packet49);
     p = packet49;
     p_length = ABSL_ARRAYSIZE(packet49);
   }
@@ -14776,6 +14816,7 @@
   unsigned char* p = packet;
   size_t p_length = ABSL_ARRAYSIZE(packet);
   if (framer_.version().HasLongHeaderLengths()) {
+    ReviseFirstByteByVersion(packet49);
     p = packet49;
     p_length = ABSL_ARRAYSIZE(packet49);
   }
@@ -15615,6 +15656,7 @@
   };
   // clang-format on
 
+  ReviseFirstByteByVersion(packet);
   QuicEncryptedPacket encrypted(AsChars(packet), ABSL_ARRAYSIZE(packet), false);
 
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index d06e1fe..88ae992 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -312,6 +312,7 @@
                                            std::string* error_details) override;
   void OnHandshakeCallbackDone() override;
   bool PacketFlusherAttached() const override;
+  ParsedQuicVersion parsed_version() const override { return version(); }
 
   // Implement StreamDelegateInterface.
   void OnStreamError(QuicErrorCode error_code,
diff --git a/quic/core/quic_version_manager.cc b/quic/core/quic_version_manager.cc
index 13e590d..4a84797 100644
--- a/quic/core/quic_version_manager.cc
+++ b/quic/core/quic_version_manager.cc
@@ -36,9 +36,11 @@
 }
 
 void QuicVersionManager::MaybeRefilterSupportedVersions() {
-  static_assert(SupportedVersions().size() == 5u,
+  static_assert(SupportedVersions().size() == 6u,
                 "Supported versions out of sync");
-  if (disable_version_rfcv1_ !=
+  if (enable_version_2_draft_01_ !=
+          GetQuicReloadableFlag(quic_enable_version_2_draft_01) ||
+      disable_version_rfcv1_ !=
           GetQuicReloadableFlag(quic_disable_version_rfcv1) ||
       disable_version_draft_29_ !=
           GetQuicReloadableFlag(quic_disable_version_draft_29) ||
@@ -48,6 +50,8 @@
           GetQuicReloadableFlag(quic_disable_version_q046) ||
       disable_version_q043_ !=
           GetQuicReloadableFlag(quic_disable_version_q043)) {
+    enable_version_2_draft_01_ =
+        GetQuicReloadableFlag(quic_enable_version_2_draft_01);
     disable_version_rfcv1_ = GetQuicReloadableFlag(quic_disable_version_rfcv1);
     disable_version_draft_29_ =
         GetQuicReloadableFlag(quic_disable_version_draft_29);
diff --git a/quic/core/quic_version_manager.h b/quic/core/quic_version_manager.h
index af44d34..44e134a 100644
--- a/quic/core/quic_version_manager.h
+++ b/quic/core/quic_version_manager.h
@@ -55,6 +55,8 @@
 
  private:
   // Cached value of reloadable flags.
+  // quic_enable_version_2_draft_01 flag
+  bool enable_version_2_draft_01_ = false;
   // quic_disable_version_rfcv1 flag
   bool disable_version_rfcv1_ = true;
   // quic_disable_version_draft_29 flag
diff --git a/quic/core/quic_version_manager_test.cc b/quic/core/quic_version_manager_test.cc
index 403009a..aa4581e 100644
--- a/quic/core/quic_version_manager_test.cc
+++ b/quic/core/quic_version_manager_test.cc
@@ -18,11 +18,12 @@
 class QuicVersionManagerTest : public QuicTest {};
 
 TEST_F(QuicVersionManagerTest, QuicVersionManager) {
-  static_assert(SupportedVersions().size() == 5u,
+  static_assert(SupportedVersions().size() == 6u,
                 "Supported versions out of sync");
   for (const ParsedQuicVersion& version : AllSupportedVersions()) {
     QuicEnableVersion(version);
   }
+  QuicDisableVersion(ParsedQuicVersion::V2Draft01());
   QuicDisableVersion(ParsedQuicVersion::RFCv1());
   QuicDisableVersion(ParsedQuicVersion::Draft29());
   QuicVersionManager manager(AllSupportedVersions());
@@ -65,6 +66,20 @@
             manager.GetSupportedVersionsWithOnlyHttp3());
   EXPECT_THAT(manager.GetSupportedAlpns(),
               ElementsAre("h3", "h3-29", "h3-Q050", "h3-Q046", "h3-Q043"));
+
+  offset++;
+  QuicEnableVersion(ParsedQuicVersion::V2Draft01());
+  expected_parsed_versions.insert(expected_parsed_versions.begin(),
+                                  ParsedQuicVersion::V2Draft01());
+  EXPECT_EQ(expected_parsed_versions, manager.GetSupportedVersions());
+  EXPECT_EQ(FilterSupportedVersions(AllSupportedVersions()),
+            manager.GetSupportedVersions());
+  EXPECT_EQ(3u, manager.GetSupportedVersionsWithOnlyHttp3().size());
+  EXPECT_EQ(CurrentSupportedHttp3Versions(),
+            manager.GetSupportedVersionsWithOnlyHttp3());
+  EXPECT_THAT(
+      manager.GetSupportedAlpns(),
+      ElementsAre("h3", "h3", "h3-29", "h3-Q050", "h3-Q046", "h3-Q043"));
 }
 
 }  // namespace
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index 4c9e661..63d21a1 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -42,11 +42,13 @@
 }
 
 void SetVersionFlag(const ParsedQuicVersion& version, bool should_enable) {
-  static_assert(SupportedVersions().size() == 5u,
+  static_assert(SupportedVersions().size() == 6u,
                 "Supported versions out of sync");
   const bool enable = should_enable;
   const bool disable = !should_enable;
-  if (version == ParsedQuicVersion::RFCv1()) {
+  if (version == ParsedQuicVersion::V2Draft01()) {
+    SetQuicReloadableFlag(quic_enable_version_2_draft_01, enable);
+  } else if (version == ParsedQuicVersion::RFCv1()) {
     SetQuicReloadableFlag(quic_disable_version_rfcv1, disable);
   } else if (version == ParsedQuicVersion::Draft29()) {
     SetQuicReloadableFlag(quic_disable_version_draft_29, disable);
@@ -182,6 +184,11 @@
   return handshake_protocol == PROTOCOL_QUIC_CRYPTO;
 }
 
+bool ParsedQuicVersion::UsesV2PacketTypes() const {
+  QUICHE_DCHECK(IsKnown());
+  return transport_version == QUIC_VERSION_IETF_2_DRAFT_01;
+}
+
 bool VersionHasLengthPrefixedConnectionIds(
     QuicTransportVersion transport_version) {
   QUICHE_DCHECK(transport_version != QUIC_VERSION_UNSUPPORTED);
@@ -213,9 +220,11 @@
 }
 
 QuicVersionLabel CreateQuicVersionLabel(ParsedQuicVersion parsed_version) {
-  static_assert(SupportedVersions().size() == 5u,
+  static_assert(SupportedVersions().size() == 6u,
                 "Supported versions out of sync");
-  if (parsed_version == ParsedQuicVersion::RFCv1()) {
+  if (parsed_version == ParsedQuicVersion::V2Draft01()) {
+    return MakeVersionLabel(0x70, 0x9a, 0x50, 0xc4);
+  } else if (parsed_version == ParsedQuicVersion::RFCv1()) {
     return MakeVersionLabel(0x00, 0x00, 0x00, 0x01);
   } else if (parsed_version == ParsedQuicVersion::Draft29()) {
     return MakeVersionLabel(0xff, 0x00, 0x00, 29);
@@ -411,10 +420,16 @@
 
 ParsedQuicVersionVector FilterSupportedVersions(
     ParsedQuicVersionVector versions) {
+  static_assert(SupportedVersions().size() == 6u,
+                "Supported versions out of sync");
   ParsedQuicVersionVector filtered_versions;
   filtered_versions.reserve(versions.size());
   for (const ParsedQuicVersion& version : versions) {
-    if (version == ParsedQuicVersion::RFCv1()) {
+    if (version == ParsedQuicVersion::V2Draft01()) {
+      if (GetQuicReloadableFlag(quic_enable_version_2_draft_01)) {
+        filtered_versions.push_back(version);
+      }
+    } else if (version == ParsedQuicVersion::RFCv1()) {
       if (!GetQuicReloadableFlag(quic_disable_version_rfcv1)) {
         filtered_versions.push_back(version);
       }
@@ -444,8 +459,7 @@
 }
 
 ParsedQuicVersionVector ParsedVersionOfIndex(
-    const ParsedQuicVersionVector& versions,
-    int index) {
+    const ParsedQuicVersionVector& versions, int index) {
   ParsedQuicVersionVector version;
   int version_count = versions.size();
   if (index >= 0 && index < version_count) {
@@ -461,8 +475,7 @@
 }
 
 std::string QuicVersionLabelVectorToString(
-    const QuicVersionLabelVector& version_labels,
-    const std::string& separator,
+    const QuicVersionLabelVector& version_labels, const std::string& separator,
     size_t skip_after_nth_version) {
   std::string result;
   for (size_t i = 0; i < version_labels.size(); ++i) {
@@ -490,6 +503,7 @@
     RETURN_STRING_LITERAL(QUIC_VERSION_50);
     RETURN_STRING_LITERAL(QUIC_VERSION_IETF_DRAFT_29);
     RETURN_STRING_LITERAL(QUIC_VERSION_IETF_RFC_V1);
+    RETURN_STRING_LITERAL(QUIC_VERSION_IETF_2_DRAFT_01);
     RETURN_STRING_LITERAL(QUIC_VERSION_UNSUPPORTED);
     RETURN_STRING_LITERAL(QUIC_VERSION_RESERVED_FOR_NEGOTIATION);
   }
@@ -508,10 +522,13 @@
 }
 
 std::string ParsedQuicVersionToString(ParsedQuicVersion version) {
-  static_assert(SupportedVersions().size() == 5u,
+  static_assert(SupportedVersions().size() == 6u,
                 "Supported versions out of sync");
   if (version == UnsupportedQuicVersion()) {
     return "0";
+  } else if (version == ParsedQuicVersion::V2Draft01()) {
+    QUICHE_DCHECK(version.UsesHttp3());
+    return "v2draft01";
   } else if (version == ParsedQuicVersion::RFCv1()) {
     QUICHE_DCHECK(version.UsesHttp3());
     return "RFCv1";
@@ -536,8 +553,7 @@
 }
 
 std::string ParsedQuicVersionVectorToString(
-    const ParsedQuicVersionVector& versions,
-    const std::string& separator,
+    const ParsedQuicVersionVector& versions, const std::string& separator,
     size_t skip_after_nth_version) {
   std::string result;
   for (size_t i = 0; i < versions.size(); ++i) {
@@ -604,7 +620,9 @@
 }
 
 std::string AlpnForVersion(ParsedQuicVersion parsed_version) {
-  if (parsed_version == ParsedQuicVersion::RFCv1()) {
+  if (parsed_version == ParsedQuicVersion::V2Draft01()) {
+    return "h3";
+  } else if (parsed_version == ParsedQuicVersion::RFCv1()) {
     return "h3";
   } else if (parsed_version == ParsedQuicVersion::Draft29()) {
     return "h3-29";
diff --git a/quic/core/quic_versions.h b/quic/core/quic_versions.h
index 331a99c..6c2144a 100644
--- a/quic/core/quic_versions.h
+++ b/quic/core/quic_versions.h
@@ -122,8 +122,9 @@
   // Number 70 used to represent draft-ietf-quic-transport-25.
   // Number 71 used to represent draft-ietf-quic-transport-27.
   // Number 72 used to represent draft-ietf-quic-transport-28.
-  QUIC_VERSION_IETF_DRAFT_29 = 73,  // draft-ietf-quic-transport-29.
-  QUIC_VERSION_IETF_RFC_V1 = 80,    // RFC 9000.
+  QUIC_VERSION_IETF_DRAFT_29 = 73,    // draft-ietf-quic-transport-29.
+  QUIC_VERSION_IETF_RFC_V1 = 80,      // RFC 9000.
+  QUIC_VERSION_IETF_2_DRAFT_01 = 81,  // draft-ietf-quic-v2-01.
   // Version 99 was a dumping ground for IETF QUIC changes which were not yet
   // ready for production between 2018-02 and 2020-02.
 
@@ -171,6 +172,7 @@
     QuicTransportVersion transport_version) {
   bool transport_version_is_valid = false;
   constexpr QuicTransportVersion valid_transport_versions[] = {
+      QUIC_VERSION_IETF_2_DRAFT_01,
       QUIC_VERSION_IETF_RFC_V1,
       QUIC_VERSION_IETF_DRAFT_29,
       QUIC_VERSION_50,
@@ -195,7 +197,8 @@
       return transport_version != QUIC_VERSION_UNSUPPORTED &&
              transport_version != QUIC_VERSION_RESERVED_FOR_NEGOTIATION &&
              transport_version != QUIC_VERSION_IETF_DRAFT_29 &&
-             transport_version != QUIC_VERSION_IETF_RFC_V1;
+             transport_version != QUIC_VERSION_IETF_RFC_V1 &&
+             transport_version != QUIC_VERSION_IETF_2_DRAFT_01;
     case PROTOCOL_TLS1_3:
       return transport_version != QUIC_VERSION_UNSUPPORTED &&
              transport_version != QUIC_VERSION_50 &&
@@ -245,6 +248,10 @@
            transport_version != other.transport_version;
   }
 
+  static constexpr ParsedQuicVersion V2Draft01() {
+    return ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_IETF_2_DRAFT_01);
+  }
+
   static constexpr ParsedQuicVersion RFCv1() {
     return ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_IETF_RFC_V1);
   }
@@ -361,6 +368,9 @@
 
   // Returns whether this version uses PROTOCOL_QUIC_CRYPTO.
   bool UsesQuicCrypto() const;
+
+  // Returns whether this version uses the QUICv2 Long Header Packet Types.
+  bool UsesV2PacketTypes() const;
 };
 
 QUIC_EXPORT_PRIVATE ParsedQuicVersion UnsupportedQuicVersion();
@@ -377,8 +387,7 @@
 using ParsedQuicVersionVector = std::vector<ParsedQuicVersion>;
 
 QUIC_EXPORT_PRIVATE std::ostream& operator<<(
-    std::ostream& os,
-    const ParsedQuicVersionVector& versions);
+    std::ostream& os, const ParsedQuicVersionVector& versions);
 
 // Representation of the on-the-wire QUIC version number. Will be written/read
 // to the wire in network-byte-order.
@@ -386,27 +395,25 @@
 using QuicVersionLabelVector = std::vector<QuicVersionLabel>;
 
 QUIC_EXPORT_PRIVATE std::ostream& operator<<(
-    std::ostream& os,
-    const QuicVersionLabelVector& version_labels);
+    std::ostream& os, const QuicVersionLabelVector& version_labels);
 
 // This vector contains all crypto handshake protocols that are supported.
 constexpr std::array<HandshakeProtocol, 2> SupportedHandshakeProtocols() {
   return {PROTOCOL_TLS1_3, PROTOCOL_QUIC_CRYPTO};
 }
 
-constexpr std::array<ParsedQuicVersion, 5> SupportedVersions() {
+constexpr std::array<ParsedQuicVersion, 6> SupportedVersions() {
   return {
-      ParsedQuicVersion::RFCv1(), ParsedQuicVersion::Draft29(),
-      ParsedQuicVersion::Q050(),  ParsedQuicVersion::Q046(),
-      ParsedQuicVersion::Q043(),
+      ParsedQuicVersion::V2Draft01(), ParsedQuicVersion::RFCv1(),
+      ParsedQuicVersion::Draft29(),   ParsedQuicVersion::Q050(),
+      ParsedQuicVersion::Q046(),      ParsedQuicVersion::Q043(),
   };
 }
 
 using QuicTransportVersionVector = std::vector<QuicTransportVersion>;
 
 QUIC_EXPORT_PRIVATE std::ostream& operator<<(
-    std::ostream& os,
-    const QuicTransportVersionVector& transport_versions);
+    std::ostream& os, const QuicTransportVersionVector& transport_versions);
 
 // Returns a vector of supported QUIC versions.
 QUIC_EXPORT_PRIVATE ParsedQuicVersionVector AllSupportedVersions();
@@ -494,8 +501,7 @@
 // QuicVersionLabel values in the supplied |version_labels| vector. The values
 // after the (0-based) |skip_after_nth_version|'th are skipped.
 QUIC_EXPORT_PRIVATE std::string QuicVersionLabelVectorToString(
-    const QuicVersionLabelVector& version_labels,
-    const std::string& separator,
+    const QuicVersionLabelVector& version_labels, const std::string& separator,
     size_t skip_after_nth_version);
 
 // Returns comma separated list of string representations of QuicVersionLabel
@@ -529,8 +535,7 @@
 // ParsedQuicVersion values in the supplied |versions| vector. The values after
 // the (0-based) |skip_after_nth_version|'th are skipped.
 QUIC_EXPORT_PRIVATE std::string ParsedQuicVersionVectorToString(
-    const ParsedQuicVersionVector& versions,
-    const std::string& separator,
+    const ParsedQuicVersionVector& versions, const std::string& separator,
     size_t skip_after_nth_version);
 
 // Returns comma separated list of string representations of ParsedQuicVersion
diff --git a/quic/core/quic_versions_test.cc b/quic/core/quic_versions_test.cc
index d60bd4d..6f384dd 100644
--- a/quic/core/quic_versions_test.cc
+++ b/quic/core/quic_versions_test.cc
@@ -120,9 +120,13 @@
             ParseQuicVersionLabel(MakeVersionLabel(0xff, 0x00, 0x00, 0x1d)));
   EXPECT_EQ(ParsedQuicVersion::RFCv1(),
             ParseQuicVersionLabel(MakeVersionLabel(0x00, 0x00, 0x00, 0x01)));
-  EXPECT_EQ((ParsedQuicVersionVector{ParsedQuicVersion::RFCv1(),
+  EXPECT_EQ(ParsedQuicVersion::V2Draft01(),
+            ParseQuicVersionLabel(MakeVersionLabel(0x70, 0x9a, 0x50, 0xc4)));
+  EXPECT_EQ((ParsedQuicVersionVector{ParsedQuicVersion::V2Draft01(),
+                                     ParsedQuicVersion::RFCv1(),
                                      ParsedQuicVersion::Draft29()}),
             ParseQuicVersionLabelVector(QuicVersionLabelVector{
+                MakeVersionLabel(0x70, 0x9a, 0x50, 0xc4),
                 MakeVersionLabel(0x00, 0x00, 0x00, 0x01),
                 MakeVersionLabel(0xaa, 0xaa, 0xaa, 0xaa),
                 MakeVersionLabel(0xff, 0x00, 0x00, 0x1d)}));
@@ -217,6 +221,8 @@
             CreateQuicVersionLabel(ParsedQuicVersion::Draft29()));
   EXPECT_EQ(MakeVersionLabel(0x00, 0x00, 0x00, 0x01),
             CreateQuicVersionLabel(ParsedQuicVersion::RFCv1()));
+  EXPECT_EQ(MakeVersionLabel(0x70, 0x9a, 0x50, 0xc4),
+            CreateQuicVersionLabel(ParsedQuicVersion::V2Draft01()));
 
   // Make sure the negotiation reserved version is in the IETF reserved space.
   EXPECT_EQ(
@@ -291,6 +297,8 @@
   EXPECT_EQ("Q050", ParsedQuicVersionToString(ParsedQuicVersion::Q050()));
   EXPECT_EQ("draft29", ParsedQuicVersionToString(ParsedQuicVersion::Draft29()));
   EXPECT_EQ("RFCv1", ParsedQuicVersionToString(ParsedQuicVersion::RFCv1()));
+  EXPECT_EQ("v2draft01",
+            ParsedQuicVersionToString(ParsedQuicVersion::V2Draft01()));
 
   ParsedQuicVersionVector versions_vector = {ParsedQuicVersion::Q043()};
   EXPECT_EQ("Q043", ParsedQuicVersionVectorToString(versions_vector));
@@ -357,23 +365,25 @@
 // yet a typo was made in doing the #defines and it was caught
 // only in some test far removed from here... Better safe than sorry.
 TEST_F(QuicVersionsTest, CheckTransportVersionNumbersForTypos) {
-  static_assert(SupportedVersions().size() == 5u,
+  static_assert(SupportedVersions().size() == 6u,
                 "Supported versions out of sync");
   EXPECT_EQ(QUIC_VERSION_43, 43);
   EXPECT_EQ(QUIC_VERSION_46, 46);
   EXPECT_EQ(QUIC_VERSION_50, 50);
   EXPECT_EQ(QUIC_VERSION_IETF_DRAFT_29, 73);
   EXPECT_EQ(QUIC_VERSION_IETF_RFC_V1, 80);
+  EXPECT_EQ(QUIC_VERSION_IETF_2_DRAFT_01, 81);
 }
 
 TEST_F(QuicVersionsTest, AlpnForVersion) {
-  static_assert(SupportedVersions().size() == 5u,
+  static_assert(SupportedVersions().size() == 6u,
                 "Supported versions out of sync");
   EXPECT_EQ("h3-Q043", AlpnForVersion(ParsedQuicVersion::Q043()));
   EXPECT_EQ("h3-Q046", AlpnForVersion(ParsedQuicVersion::Q046()));
   EXPECT_EQ("h3-Q050", AlpnForVersion(ParsedQuicVersion::Q050()));
   EXPECT_EQ("h3-29", AlpnForVersion(ParsedQuicVersion::Draft29()));
   EXPECT_EQ("h3", AlpnForVersion(ParsedQuicVersion::RFCv1()));
+  EXPECT_EQ("h3", AlpnForVersion(ParsedQuicVersion::V2Draft01()));
 }
 
 TEST_F(QuicVersionsTest, QuicVersionEnabling) {
@@ -423,8 +433,12 @@
       EXPECT_NE(CreateQuicVersionLabel(version1),
                 CreateQuicVersionLabel(version2))
           << version1 << " " << version2;
-      EXPECT_NE(AlpnForVersion(version1), AlpnForVersion(version2))
-          << version1 << " " << version2;
+      // The one pair where ALPNs are the same.
+      if ((version1 != ParsedQuicVersion::V2Draft01()) &&
+          (version2 != ParsedQuicVersion::RFCv1())) {
+        EXPECT_NE(AlpnForVersion(version1), AlpnForVersion(version2))
+            << version1 << " " << version2;
+      }
     }
   }
 }
diff --git a/quic/core/tls_handshaker.cc b/quic/core/tls_handshaker.cc
index ad7dafb..2eee1cc 100644
--- a/quic/core/tls_handshaker.cc
+++ b/quic/core/tls_handshaker.cc
@@ -25,8 +25,7 @@
 TlsHandshaker::ProofVerifierCallbackImpl::~ProofVerifierCallbackImpl() {}
 
 void TlsHandshaker::ProofVerifierCallbackImpl::Run(
-    bool ok,
-    const std::string& /*error_details*/,
+    bool ok, const std::string& /*error_details*/,
     std::unique_ptr<ProofVerifyDetails>* details) {
   if (parent_ == nullptr) {
     return;
@@ -42,9 +41,7 @@
   parent_->AdvanceHandshake();
 }
 
-void TlsHandshaker::ProofVerifierCallbackImpl::Cancel() {
-  parent_ = nullptr;
-}
+void TlsHandshaker::ProofVerifierCallbackImpl::Cancel() { parent_ = nullptr; }
 
 TlsHandshaker::TlsHandshaker(QuicCryptoStream* stream, QuicSession* session)
     : stream_(stream), handshaker_delegate_(session) {}
@@ -243,10 +240,13 @@
   std::unique_ptr<QuicEncrypter> encrypter =
       QuicEncrypter::CreateFromCipherSuite(SSL_CIPHER_get_id(cipher));
   const EVP_MD* prf = Prf(cipher);
-  CryptoUtils::SetKeyAndIV(prf, write_secret, encrypter.get());
+  CryptoUtils::SetKeyAndIV(prf, write_secret,
+                           handshaker_delegate_->parsed_version(),
+                           encrypter.get());
   std::vector<uint8_t> header_protection_key =
-      CryptoUtils::GenerateHeaderProtectionKey(prf, write_secret,
-                                               encrypter->GetKeySize());
+      CryptoUtils::GenerateHeaderProtectionKey(
+          prf, write_secret, handshaker_delegate_->parsed_version(),
+          encrypter->GetKeySize());
   encrypter->SetHeaderProtectionKey(
       absl::string_view(reinterpret_cast<char*>(header_protection_key.data()),
                         header_protection_key.size()));
@@ -266,10 +266,13 @@
   std::unique_ptr<QuicDecrypter> decrypter =
       QuicDecrypter::CreateFromCipherSuite(SSL_CIPHER_get_id(cipher));
   const EVP_MD* prf = Prf(cipher);
-  CryptoUtils::SetKeyAndIV(prf, read_secret, decrypter.get());
+  CryptoUtils::SetKeyAndIV(prf, read_secret,
+                           handshaker_delegate_->parsed_version(),
+                           decrypter.get());
   std::vector<uint8_t> header_protection_key =
-      CryptoUtils::GenerateHeaderProtectionKey(prf, read_secret,
-                                               decrypter->GetKeySize());
+      CryptoUtils::GenerateHeaderProtectionKey(
+          prf, read_secret, handshaker_delegate_->parsed_version(),
+          decrypter->GetKeySize());
   decrypter->SetHeaderProtectionKey(
       absl::string_view(reinterpret_cast<char*>(header_protection_key.data()),
                         header_protection_key.size()));
@@ -296,14 +299,16 @@
   }
   const SSL_CIPHER* cipher = SSL_get_current_cipher(ssl());
   const EVP_MD* prf = Prf(cipher);
-  latest_read_secret_ =
-      CryptoUtils::GenerateNextKeyPhaseSecret(prf, latest_read_secret_);
-  latest_write_secret_ =
-      CryptoUtils::GenerateNextKeyPhaseSecret(prf, latest_write_secret_);
+  latest_read_secret_ = CryptoUtils::GenerateNextKeyPhaseSecret(
+      prf, handshaker_delegate_->parsed_version(), latest_read_secret_);
+  latest_write_secret_ = CryptoUtils::GenerateNextKeyPhaseSecret(
+      prf, handshaker_delegate_->parsed_version(), latest_write_secret_);
 
   std::unique_ptr<QuicDecrypter> decrypter =
       QuicDecrypter::CreateFromCipherSuite(SSL_CIPHER_get_id(cipher));
-  CryptoUtils::SetKeyAndIV(prf, latest_read_secret_, decrypter.get());
+  CryptoUtils::SetKeyAndIV(prf, latest_read_secret_,
+                           handshaker_delegate_->parsed_version(),
+                           decrypter.get());
   decrypter->SetHeaderProtectionKey(absl::string_view(
       reinterpret_cast<char*>(one_rtt_read_header_protection_key_.data()),
       one_rtt_read_header_protection_key_.size()));
@@ -322,7 +327,9 @@
   const SSL_CIPHER* cipher = SSL_get_current_cipher(ssl());
   std::unique_ptr<QuicEncrypter> encrypter =
       QuicEncrypter::CreateFromCipherSuite(SSL_CIPHER_get_id(cipher));
-  CryptoUtils::SetKeyAndIV(Prf(cipher), latest_write_secret_, encrypter.get());
+  CryptoUtils::SetKeyAndIV(Prf(cipher), latest_write_secret_,
+                           handshaker_delegate_->parsed_version(),
+                           encrypter.get());
   encrypter->SetHeaderProtectionKey(absl::string_view(
       reinterpret_cast<char*>(one_rtt_write_header_protection_key_.data()),
       one_rtt_write_header_protection_key_.size()));