remove QuicVersion::QUIC_DRAFT

Summary: - as title, deprecate QuicVersion::QUIC_DRAFT

Reviewed By: jbeshay

Differential Revision: D50466992

fbshipit-source-id: 2b2776d142142bc07fd27053a68dd635959a7f31

quic/QuicConstants.cpp

@@ -89,7 +89,6 @@ std::vector<QuicVersion> filterSupportedVersions(
         return version == QuicVersion::MVFST ||
             version == QuicVersion::QUIC_V1 ||
             version == QuicVersion::QUIC_V1_ALIAS ||
-            version == QuicVersion::QUIC_DRAFT ||
             version == QuicVersion::MVFST_INVALID ||
             version == QuicVersion::MVFST_EXPERIMENTAL ||
             version == QuicVersion::MVFST_ALIAS;

quic/QuicConstants.h

@@ -333,7 +333,6 @@ enum class QuicVersion : uint32_t {
   // QuicTransportBase::isKnobSupported() and make sure that knob support is not
   // broken.
   MVFST = 0xfaceb002,
-  QUIC_DRAFT = 0xff00001d, // Draft-29
   QUIC_V1 = 0x00000001,
   QUIC_V1_ALIAS = 0xfaceb003,
   // MVFST_EXPERIMENTAL used to set initial congestion window

quic/api/test/QuicPacketSchedulerTest.cpp

@@ -38,7 +38,7 @@ PacketNum addInitialOutstandingPacket(QuicConnectionStateBase& conn) {
       srcConnId,
       conn.clientConnectionId.value_or(quic::test::getTestConnectionId()),
       nextPacketNum,
-      QuicVersion::QUIC_DRAFT);
+      QuicVersion::MVFST);
   RegularQuicWritePacket packet(std::move(header));
   conn.outstandings.packets.emplace_back(
       packet,
@@ -68,7 +68,7 @@ PacketNum addHandshakeOutstandingPacket(QuicConnectionStateBase& conn) {
       srcConnId,
       conn.clientConnectionId.value_or(quic::test::getTestConnectionId()),
       nextPacketNum,
-      QuicVersion::QUIC_DRAFT);
+      QuicVersion::MVFST);
   RegularQuicWritePacket packet(std::move(header));
   conn.outstandings.packets.emplace_back(
       packet,
@@ -697,7 +697,7 @@ TEST_F(QuicPacketSchedulerTest, CloneSchedulerHasHandshakeDataAndAcks) {
       srcConnId,
       conn.clientConnectionId.value_or(quic::test::getTestConnectionId()),
       nextPacketNum,
-      QuicVersion::QUIC_DRAFT);
+      QuicVersion::MVFST);
   RegularQuicPacketBuilder builder(
       conn.udpSendPacketLen,
       std::move(header),

quic/client/state/ClientStateMachine.cpp

@@ -151,8 +151,7 @@ void processServerInitialParams(
       static_cast<TransportParameterId>(
           TransportParameterId::knob_frames_supported),
       serverParams.parameters);
-  if (conn.version == QuicVersion::QUIC_DRAFT ||
+  if (conn.version == QuicVersion::QUIC_V1 ||
-      conn.version == QuicVersion::QUIC_V1 ||
       conn.version == QuicVersion::QUIC_V1_ALIAS) {
     auto initialSourceConnId = getConnIdParameter(
         TransportParameterId::initial_source_connection_id,

quic/codec/Types.cpp

@@ -463,8 +463,6 @@ std::string toString(QuicVersion version) {
       return "QUIC_V1";
     case QuicVersion::QUIC_V1_ALIAS:
       return "QUIC_V1_ALIAS";
-    case QuicVersion::QUIC_DRAFT:
-      return "QUIC_DRAFT";
     case QuicVersion::MVFST_EXPERIMENTAL:
       return "MVFST_EXPERIMENTAL";
     case QuicVersion::MVFST_ALIAS:

quic/codec/test/TypesTest.cpp

@@ -49,14 +49,14 @@ folly::Expected<ParsedLongHeaderResult, TransportErrorCode> makeLongHeader(
       getTestConnectionId(),
       getTestConnectionId(),
       321,
-      QuicVersion::QUIC_DRAFT);
+      QuicVersion::MVFST);
 
   LongHeader headerRetry(
       packetType,
       getTestConnectionId(),
       getTestConnectionId(),
       321,
-      QuicVersion::QUIC_DRAFT,
+      QuicVersion::MVFST,
       std::string("this is a retry token :)"));
 
   RegularQuicPacketBuilder builder(
@@ -213,7 +213,7 @@ TEST_F(TypesTest, LongHeaderPacketNumberSpace) {
       getTestConnectionId(0),
       getTestConnectionId(1),
       200,
-      QuicVersion::QUIC_DRAFT);
+      QuicVersion::MVFST);
   EXPECT_EQ(
       PacketNumberSpace::Initial, initialLongHeader.getPacketNumberSpace());
   EXPECT_EQ(
@@ -225,7 +225,7 @@ TEST_F(TypesTest, LongHeaderPacketNumberSpace) {
       getTestConnectionId(2),
       getTestConnectionId(3),
       201,
-      QuicVersion::QUIC_DRAFT);
+      QuicVersion::MVFST);
   EXPECT_EQ(PacketNumberSpace::Initial, retryLongHeader.getPacketNumberSpace());
   EXPECT_EQ(
       PacketNumberSpace::Initial,
@@ -236,7 +236,7 @@ TEST_F(TypesTest, LongHeaderPacketNumberSpace) {
       getTestConnectionId(4),
       getTestConnectionId(5),
       202,
-      QuicVersion::QUIC_DRAFT);
+      QuicVersion::MVFST);
   EXPECT_EQ(
       PacketNumberSpace::Handshake, handshakeLongHeader.getPacketNumberSpace());
   EXPECT_EQ(
@@ -249,7 +249,7 @@ TEST_F(TypesTest, LongHeaderPacketNumberSpace) {
       getTestConnectionId(6),
       getTestConnectionId(7),
       203,
-      QuicVersion::QUIC_DRAFT);
+      QuicVersion::MVFST);
   EXPECT_EQ(
       PacketNumberSpace::AppData, zeroRttLongHeader.getPacketNumberSpace());
   EXPECT_EQ(
@@ -266,7 +266,7 @@ TEST_F(PacketHeaderTest, LongHeader) {
       getTestConnectionId(4),
       getTestConnectionId(5),
       packetNumber,
-      QuicVersion::QUIC_DRAFT);
+      QuicVersion::MVFST);
   PacketHeader readHeader(std::move(handshakeLongHeader));
   EXPECT_NE(readHeader.asLong(), nullptr);
   EXPECT_EQ(readHeader.asShort(), nullptr);

quic/common/test/TestUtils.cpp

@@ -605,14 +605,14 @@ RegularQuicWritePacket createNewPacket(
           getTestConnectionId(1),
           getTestConnectionId(2),
           packetNum,
-          QuicVersion::QUIC_DRAFT));
+          QuicVersion::MVFST));
     case PacketNumberSpace::Handshake:
       return RegularQuicWritePacket(LongHeader(
           LongHeader::Types::Handshake,
           getTestConnectionId(0),
           getTestConnectionId(4),
           packetNum,
-          QuicVersion::QUIC_DRAFT));
+          QuicVersion::MVFST));
     case PacketNumberSpace::AppData:
       return RegularQuicWritePacket(ShortHeader(
           ProtectionType::KeyPhaseOne, getTestConnectionId(), packetNum));

quic/fizz/client/handshake/FizzClientExtensions.h

@@ -55,8 +55,7 @@ class FizzClientExtensions : public fizz::ClientExtensions {
     params.parameters.push_back(encodeIntegerParameter(
         TransportParameterId::active_connection_id_limit,
         clientParameters_->activeConnectionLimit_));
-    if (clientParameters_->encodingVersion_ == QuicVersion::QUIC_DRAFT ||
+    if (clientParameters_->encodingVersion_ == QuicVersion::QUIC_V1 ||
-        clientParameters_->encodingVersion_ == QuicVersion::QUIC_V1 ||
         clientParameters_->encodingVersion_ == QuicVersion::QUIC_V1_ALIAS) {
       params.parameters.push_back(encodeConnIdParameter(
           TransportParameterId::initial_source_connection_id,

quic/fizz/client/handshake/test/FizzClientExtensionsTest.cpp

@@ -48,28 +48,6 @@ TEST(FizzClientHandshakeTest, TestGetChloExtensionsMvfst) {
   EXPECT_EQ(clientParams->parameters.size(), 10);
 }
 
-TEST(FizzClientHandshakeTest, TestGetChloExtensions) {
-  FizzClientExtensions ext(std::make_shared<ClientTransportParametersExtension>(
-      QuicVersion::QUIC_DRAFT,
-      kDefaultConnectionFlowControlWindow,
-      kDefaultStreamFlowControlWindow,
-      kDefaultStreamFlowControlWindow,
-      kDefaultStreamFlowControlWindow,
-      kDefaultMaxStreamsBidirectional,
-      kDefaultMaxStreamsUnidirectional,
-      kDefaultIdleTimeout,
-      kDefaultAckDelayExponent,
-      kDefaultUDPSendPacketLen,
-      kDefaultActiveConnectionIdLimit,
-      ConnectionId(std::vector<uint8_t>())));
-  auto extensions = ext.getClientHelloExtensions();
-
-  EXPECT_EQ(extensions.size(), 1);
-  auto clientParams = getClientExtension(extensions, QuicVersion::QUIC_DRAFT);
-  ASSERT_TRUE(clientParams.has_value());
-  EXPECT_EQ(clientParams->parameters.size(), 11);
-}
-
 TEST(FizzClientHandshakeTest, TestGetChloExtensionsV1) {
   FizzClientExtensions ext(std::make_shared<ClientTransportParametersExtension>(
       QuicVersion::QUIC_V1,
@@ -151,8 +129,7 @@ TEST(FizzClientHandshakeTest, TestV1RejectExtensionNumberMismatch) {
 
   auto ee = TestMessages::encryptedExt();
   ServerTransportParameters serverParams;
-  ee.extensions.push_back(
+  ee.extensions.push_back(encodeExtension(serverParams, QuicVersion::MVFST));
-      encodeExtension(serverParams, QuicVersion::QUIC_DRAFT));
 
   EXPECT_THROW(ext.onEncryptedExtensions(ee.extensions), FizzException);
 

quic/fizz/client/test/QuicClientTransportTest.cpp

@@ -979,9 +979,7 @@ INSTANTIATE_TEST_SUITE_P(
         TestingParams(QuicVersion::QUIC_V1),
         TestingParams(QuicVersion::QUIC_V1, 0),
         TestingParams(QuicVersion::QUIC_V1_ALIAS),
-        TestingParams(QuicVersion::QUIC_V1_ALIAS, 0),
+        TestingParams(QuicVersion::QUIC_V1_ALIAS, 0)));
-        TestingParams(QuicVersion::QUIC_DRAFT),
-        TestingParams(QuicVersion::QUIC_DRAFT, 0)));
 
 class QuicClientTransportTest : public QuicClientTransportTestBase {
  public:
@@ -3274,8 +3272,7 @@ INSTANTIATE_TEST_SUITE_P(
     Values(
         QuicVersion::MVFST,
         QuicVersion::QUIC_V1,
-        QuicVersion::QUIC_V1_ALIAS,
+        QuicVersion::QUIC_V1_ALIAS));
-        QuicVersion::QUIC_DRAFT));
 
 TEST_P(
     QuicClientTransportAfterStartTestTimeout,

quic/fizz/client/test/QuicClientTransportTestUtil.h

@@ -411,8 +411,7 @@ class QuicClientTransportTestBase : public virtual testing::Test {
         {QuicVersion::MVFST,
          MVFST1,
          QuicVersion::QUIC_V1,
-         QuicVersion::QUIC_V1_ALIAS,
+         QuicVersion::QUIC_V1_ALIAS});
-         QuicVersion::QUIC_DRAFT});
     connIdAlgo_ = std::make_unique<DefaultConnectionIdAlgo>();
     ON_CALL(*sock, resumeRead(testing::_))
         .WillByDefault(testing::SaveArg<0>(&networkReadCallback));

quic/fizz/handshake/FizzTransportParameters.h

@@ -192,17 +192,6 @@ inline void validateTransportExtensions(
                 "unexpected extension type ({:#x}) for quic v1",
                 extension.extension_type),
             fizz::AlertDescription::illegal_parameter);
-      } else if (
-          encodingVersion == quic::QuicVersion::QUIC_DRAFT &&
-          extension.extension_type !=
-              fizz::ExtensionType::quic_transport_parameters_draft) {
-        // This is a QUIC draft version using an incorrect transport parameters
-        // extension type
-        throw fizz::FizzException(
-            fmt::format(
-                "unexpected extension type ({:#x}) for quic draft version",
-                extension.extension_type),
-            fizz::AlertDescription::illegal_parameter);
       }
       found = true;
     }

quic/fizz/handshake/test/FizzCryptoFactoryTest.cpp

@@ -62,29 +62,6 @@ class FizzCryptoFactoryTest : public Test {
   folly::Optional<std::unique_ptr<folly::IOBuf>> packetCipherKey_;
 };
 
-TEST_F(FizzCryptoFactoryTest, TestDraft29ClearTextCipher) {
-  // test vector taken from
-  // https://tools.ietf.org/html/draft-ietf-quic-tls-29#appendix-A
-  auto connid = folly::unhexlify("8394c8f03e515708");
-  std::vector<uint8_t> destinationConnidVector;
-  for (size_t i = 0; i < connid.size(); ++i) {
-    destinationConnidVector.push_back(connid.data()[i]);
-  }
-  ConnectionId destinationConnid(destinationConnidVector);
-  auto fizzFactory = std::make_shared<QuicFizzTestFactory>();
-  fizzFactory->setMockAead(createMockAead());
-  auto aead =
-      FizzCryptoTestFactory(fizzFactory)
-          .getClientInitialCipher(destinationConnid, QuicVersion::QUIC_DRAFT);
-
-  std::string expectedKey = "175257a31eb09dea9366d8bb79ad80ba";
-  std::string expectedIv = "6b26114b9cba2b63a9e8dd4f";
-  auto trafficKeyHex = folly::hexlify(trafficKey_->key->coalesce());
-  auto trafficIvHex = folly::hexlify(trafficKey_->iv->coalesce());
-  EXPECT_EQ(trafficKeyHex, expectedKey);
-  EXPECT_EQ(trafficIvHex, expectedIv);
-}
-
 TEST_F(FizzCryptoFactoryTest, TestV1ClearTextCipher) {
   // test vector taken from
   // https://datatracker.ietf.org/doc/html/rfc9001#appendix-A

quic/fizz/handshake/test/FizzTransportParametersTest.cpp

@@ -56,6 +56,8 @@ StringPiece serverParamsD29{"ffa500100008121254761256146904049d7f3e7d"};
 StringPiece ticketParamsV1{"0039000604049d7f3e7d"};
 StringPiece ticketParamsD29{"ffa5000604049d7f3e7d"};
 
+constexpr QuicVersion kQuicDraft = static_cast<QuicVersion>(0xff00001d);
+
 TEST_F(QuicExtensionsTest, TestClientParamsV1) {
   auto exts = getExtensions(clientParamsV1);
   auto ext = getClientExtension(exts, QuicVersion::QUIC_V1);
@@ -70,13 +72,13 @@ TEST_F(QuicExtensionsTest, TestClientParamsV1) {
 
   // Confirm D29 parameters are not parsed for V1.
   auto d29Exts = getExtensions(clientParamsD29);
-  auto d2Ext = getClientExtension(exts, QuicVersion::QUIC_DRAFT);
+  auto d2Ext = getClientExtension(exts, kQuicDraft);
   EXPECT_EQ(d2Ext, folly::none);
 }
 
 TEST_F(QuicExtensionsTest, TestClientParamsD29) {
   auto exts = getExtensions(clientParamsD29);
-  auto ext = getClientExtension(exts, QuicVersion::QUIC_DRAFT);
+  auto ext = getClientExtension(exts, kQuicDraft);
   EXPECT_EQ(ext->parameters.size(), 1);
   EXPECT_EQ(
       ext->parameters[0].parameter, TransportParameterId::initial_max_data);
@@ -84,7 +86,7 @@ TEST_F(QuicExtensionsTest, TestClientParamsD29) {
       *getIntegerParameter(
           TransportParameterId::initial_max_data, ext->parameters),
       494878333ULL);
-  checkEncode(std::move(*ext), clientParamsD29, QuicVersion::QUIC_DRAFT);
+  checkEncode(std::move(*ext), clientParamsD29, kQuicDraft);
 }
 
 TEST_F(QuicExtensionsTest, TestServerParamsV1) {
@@ -111,13 +113,13 @@ TEST_F(QuicExtensionsTest, TestServerParamsV1) {
 
   // Confirm D29 parameters are not parsed for V1.
   auto d29Exts = getExtensions(serverParamsD29);
-  auto d2Ext = getServerExtension(exts, QuicVersion::QUIC_DRAFT);
+  auto d2Ext = getServerExtension(exts, kQuicDraft);
   EXPECT_EQ(d2Ext, folly::none);
 }
 
 TEST_F(QuicExtensionsTest, TestServerParamsD29) {
   auto exts = getExtensions(serverParamsD29);
-  auto ext = getServerExtension(exts, QuicVersion::QUIC_DRAFT);
+  auto ext = getServerExtension(exts, kQuicDraft);
 
   EXPECT_EQ(
       ext->parameters[0].parameter,
@@ -135,7 +137,7 @@ TEST_F(QuicExtensionsTest, TestServerParamsD29) {
           TransportParameterId::original_destination_connection_id,
           ext->parameters),
       connId);
-  checkEncode(std::move(*ext), serverParamsD29, QuicVersion::QUIC_DRAFT);
+  checkEncode(std::move(*ext), serverParamsD29, kQuicDraft);
 }
 
 TEST_F(QuicExtensionsTest, TestTicketParamsV1) {
@@ -153,13 +155,13 @@ TEST_F(QuicExtensionsTest, TestTicketParamsV1) {
 
   // Confirm D29 parameters are not parsed for V1.
   auto d29Exts = getExtensions(ticketParamsD29);
-  auto d2Ext = getTicketExtension(exts, QuicVersion::QUIC_DRAFT);
+  auto d2Ext = getTicketExtension(exts, kQuicDraft);
   EXPECT_EQ(d2Ext, folly::none);
 }
 
 TEST_F(QuicExtensionsTest, TestTicketParamsD29) {
   auto exts = getExtensions(ticketParamsD29);
-  auto ext = getTicketExtension(exts, QuicVersion::QUIC_DRAFT);
+  auto ext = getTicketExtension(exts, kQuicDraft);
 
   EXPECT_EQ(ext->parameters.size(), 1);
   EXPECT_EQ(
@@ -168,7 +170,7 @@ TEST_F(QuicExtensionsTest, TestTicketParamsD29) {
       *getIntegerParameter(
           TransportParameterId::initial_max_data, ext->parameters),
       494878333ULL);
-  checkEncode(std::move(*ext), ticketParamsD29, QuicVersion::QUIC_DRAFT);
+  checkEncode(std::move(*ext), ticketParamsD29, kQuicDraft);
 }
 
 } // namespace test

quic/handshake/HandshakeLayer.cpp

@@ -30,8 +30,6 @@ folly::StringPiece getQuicVersionSalt(QuicVersion version) {
       FOLLY_FALLTHROUGH;
     case QuicVersion::QUIC_V1_ALIAS:
       return kQuicV1Salt;
-    case QuicVersion::QUIC_DRAFT:
-      return kQuicDraft29Salt;
     case QuicVersion::MVFST:
       FOLLY_FALLTHROUGH;
     default:

quic/server/QuicServer.h

@@ -393,15 +393,15 @@ class QuicServer : public QuicServerWorker::WorkerCallback,
       const folly::SocketAddress& address,
       const std::vector<folly::EventBase*>& evbs);
 
-  std::vector<QuicVersion> supportedVersions_{
+  std::vector<QuicVersion> supportedVersions_{{
-      {QuicVersion::MVFST,
+      QuicVersion::MVFST,
       QuicVersion::MVFST_EXPERIMENTAL,
       QuicVersion::MVFST_EXPERIMENTAL2,
       QuicVersion::MVFST_EXPERIMENTAL3,
       QuicVersion::MVFST_ALIAS,
       QuicVersion::QUIC_V1,
       QuicVersion::QUIC_V1_ALIAS,
-       QuicVersion::QUIC_DRAFT}};
+  }};
 
   std::atomic<bool> shutdown_{true};
   std::shared_ptr<const fizz::server::FizzServerContext> ctx_;

quic/server/handshake/ServerTransportParametersExtension.h

@@ -67,8 +67,7 @@ class ServerTransportParametersExtension : public fizz::ServerExtensions {
 
     ServerTransportParameters params;
     params.parameters.reserve(10);
-    if (encodingVersion_ == QuicVersion::QUIC_DRAFT ||
+    if (encodingVersion_ == QuicVersion::QUIC_V1 ||
-        encodingVersion_ == QuicVersion::QUIC_V1 ||
         encodingVersion_ == QuicVersion::QUIC_V1_ALIAS) {
       params.parameters.push_back(encodeConnIdParameter(
           TransportParameterId::original_destination_connection_id,
@@ -107,8 +106,7 @@ class ServerTransportParametersExtension : public fizz::ServerExtensions {
           encodeEmptyParameter(TransportParameterId::disable_migration));
     }
 
-    if (encodingVersion_ == QuicVersion::QUIC_DRAFT ||
+    if (encodingVersion_ == QuicVersion::QUIC_V1 ||
-        encodingVersion_ == QuicVersion::QUIC_V1 ||
         encodingVersion_ == QuicVersion::QUIC_V1_ALIAS) {
       params.parameters.push_back(encodeConnIdParameter(
           TransportParameterId::initial_source_connection_id,

quic/server/handshake/test/ServerHandshakeTest.cpp

@@ -66,7 +66,7 @@ class ServerHandshakeTest : public Test {
   virtual void setupClientAndServerContext() {}
 
   QuicVersion getVersion() {
-    return QuicVersion::QUIC_DRAFT;
+    return QuicVersion::MVFST;
   }
 
   virtual void initialize() {

quic/server/handshake/test/ServerTransportParametersTest.cpp

@@ -92,8 +92,7 @@ TEST(ServerTransportParametersTest, TestQuicV1RejectDraftExtensionNumber) {
       ConnectionId(std::vector<uint8_t>{0xff, 0xfe, 0xfd, 0xfc}),
       ConnectionId(std::vector<uint8_t>()));
   EXPECT_THROW(
-      ext.getExtensions(getClientHello(QuicVersion::QUIC_DRAFT)),
+      ext.getExtensions(getClientHello(QuicVersion::MVFST)), FizzException);
-      FizzException);
   EXPECT_NO_THROW(ext.getExtensions(getClientHello(QuicVersion::QUIC_V1)));
 }
 

quic/server/state/ServerStateMachine.cpp

@@ -231,8 +231,7 @@ void processClientInitialParams(
   auto receiveTimestampsExponent = getIntegerParameter(
       TransportParameterId::receive_timestamps_exponent,
       clientParams.parameters);
-  if (conn.version == QuicVersion::QUIC_DRAFT ||
+  if (conn.version == QuicVersion::QUIC_V1 ||
-      conn.version == QuicVersion::QUIC_V1 ||
       conn.version == QuicVersion::QUIC_V1_ALIAS) {
     auto initialSourceConnId = getConnIdParameter(
         TransportParameterId::initial_source_connection_id,

quic/server/state/ServerStateMachine.h

@@ -169,8 +169,7 @@ struct QuicServerConnectionState : public QuicConnectionStateBase {
          QuicVersion::MVFST_EXPERIMENTAL3,
          QuicVersion::MVFST_ALIAS,
          QuicVersion::QUIC_V1,
-         QuicVersion::QUIC_V1_ALIAS,
+         QuicVersion::QUIC_V1_ALIAS}};
-         QuicVersion::QUIC_DRAFT}};
     originalVersion = QuicVersion::MVFST;
     DCHECK(handshakeFactory);
     auto tmpServerHandshake =

quic/server/test/QuicServerTransportTest.cpp

@@ -4061,8 +4061,8 @@ TEST_F(QuicUnencryptedServerTransportTest, TestSendHandshakeDone) {
   EXPECT_CALL(handshakeFinishedCallback, onHandshakeFinished());
   getFakeHandshakeLayer()->allowZeroRttKeys();
   setupClientReadCodec();
-  recvClientHello(true, QuicVersion::QUIC_DRAFT);
+  recvClientHello(true, QuicVersion::MVFST);
-  recvClientFinished(true, nullptr, QuicVersion::QUIC_DRAFT);
+  recvClientFinished(true, nullptr, QuicVersion::MVFST);
   auto& packets = server->getConn().outstandings.packets;
   ASSERT_FALSE(packets.empty());
   int numHandshakeDone = 0;
@@ -4108,7 +4108,7 @@ TEST_F(QuicUnencryptedServerTransportTest, TestSendHandshakeDoneNewTokenFrame) {
 
   getFakeHandshakeLayer()->allowZeroRttKeys();
   setupClientReadCodec();
-  recvClientHello(true, QuicVersion::QUIC_DRAFT);
+  recvClientHello(true, QuicVersion::MVFST);
 
   /**
    * Receiving just the chlo should not issue a NewTokenFrame.
@@ -4116,7 +4116,7 @@ TEST_F(QuicUnencryptedServerTransportTest, TestSendHandshakeDoneNewTokenFrame) {
   EXPECT_EQ(getNewTokenFrame(server->getConn().outstandings.packets).first, 0);
 
   EXPECT_CALL(*quicStats_, onNewTokenIssued());
-  recvClientFinished(true, nullptr, QuicVersion::QUIC_DRAFT);
+  recvClientFinished(true, nullptr, QuicVersion::MVFST);
 
   /**
    * After the handshake is complete, we expect only one NewTokenFrame to be

quic/server/test/QuicServerTransportTestUtil.h

@@ -146,7 +146,7 @@ class QuicServerTransportTestBase : public virtual testing::Test {
             }));
     EXPECT_CALL(*sock, address())
         .WillRepeatedly(testing::ReturnRef(serverAddr));
-    supportedVersions = {QuicVersion::MVFST, QuicVersion::QUIC_DRAFT};
+    supportedVersions = {QuicVersion::MVFST};
     serverCtx = createServerCtx();
     connIdAlgo_ = std::make_unique<DefaultConnectionIdAlgo>();
     ccFactory_ = std::make_shared<ServerCongestionControllerFactory>();

quic/state/test/QuicStateFunctionsTest.cpp

@@ -50,7 +50,7 @@ RegularQuicWritePacket makeTestLongPacket(LongHeader::Types type) {
       getTestConnectionId(0),
       getTestConnectionId(1),
       2 /* packetNum */,
-      QuicVersion::QUIC_DRAFT);
+      QuicVersion::MVFST);
   RegularQuicWritePacket packet(std::move(header));
   return packet;
 }