Start splitting the fizz specific parts of the server (#160)

Summary:
This is following a similar pattern than what was done for the client side.

Pull Request resolved: https://github.com/facebookincubator/mvfst/pull/160

Reviewed By: yangchi

Differential Revision: D23560951

Pulled By: xttjsn

fbshipit-source-id: 351417cbfa3230112fff4c4de59b307f88389cf6

quic/api/test/CMakeLists.txt

@@ -51,10 +51,10 @@ quic_add_test(TARGET QuicPacketSchedulerTest
   DEPENDS
   Folly::folly
   mvfst_fizz_client
+  mvfst_server
   mvfst_codec_pktbuilder
   mvfst_transport
   mvfst_test_utils
-  mvfst_server
 )
 
 quic_add_test(TARGET IoBufQuicBatchTest

quic/api/test/QuicBatchWriterTest.cpp

@@ -10,6 +10,7 @@
 
 #include <folly/io/async/test/MockAsyncUDPSocket.h>
 #include <gtest/gtest.h>
+#include <quic/fizz/server/handshake/FizzServerQuicHandshakeContext.h>
 #include <quic/server/state/ServerStateMachine.h>
 
 using namespace testing;
@@ -25,6 +26,9 @@ constexpr const auto kNumLoops = 10;
 
 struct QuicBatchWriterTest : public ::testing::Test,
                              public ::testing::WithParamInterface<bool> {
+  QuicBatchWriterTest()
+      : conn_(std::make_shared<FizzServerQuicHandshakeContext>()) {}
+
  protected:
   QuicServerConnectionState conn_;
 };

quic/api/test/QuicPacketSchedulerTest.cpp

@@ -17,6 +17,7 @@
 #include <quic/codec/test/Mocks.h>
 #include <quic/common/test/TestUtils.h>
 #include <quic/fizz/client/handshake/FizzClientQuicHandshakeContext.h>
+#include <quic/fizz/server/handshake/FizzServerQuicHandshakeContext.h>
 #include <quic/server/state/ServerStateMachine.h>
 #include <quic/state/QuicStreamFunctions.h>
 
@@ -184,7 +185,8 @@ TEST_F(QuicPacketSchedulerTest, PaddingUpToWrapperSize) {
 }
 
 TEST_F(QuicPacketSchedulerTest, CryptoServerInitialPadded) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   auto connId = getTestConnectionId();
   PacketNum nextPacketNum = getNextPacketNum(conn, PacketNumberSpace::Initial);
   LongHeader longHeader1(
@@ -216,7 +218,8 @@ TEST_F(QuicPacketSchedulerTest, CryptoServerInitialPadded) {
 }
 
 TEST_F(QuicPacketSchedulerTest, PadTwoInitialPackets) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   auto connId = getTestConnectionId();
   PacketNum nextPacketNum = getNextPacketNum(conn, PacketNumberSpace::Initial);
   LongHeader longHeader1(
@@ -299,7 +302,8 @@ TEST_F(QuicPacketSchedulerTest, CryptoPaddingRetransmissionClientInitial) {
 }
 
 TEST_F(QuicPacketSchedulerTest, CryptoSchedulerOnlySingleLossFits) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   auto connId = getTestConnectionId();
   LongHeader longHeader(
       LongHeader::Types::Handshake,
@@ -362,7 +366,8 @@ TEST_F(QuicPacketSchedulerTest, CryptoWritePartialLossBuffer) {
 }
 
 TEST_F(QuicPacketSchedulerTest, StreamFrameSchedulerExists) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.streamManager->setMaxLocalBidirectionalStreams(10);
   auto connId = getTestConnectionId();
   auto stream = conn.streamManager->createNextBidirectionalStream().value();
@@ -384,7 +389,8 @@ TEST_F(QuicPacketSchedulerTest, StreamFrameSchedulerExists) {
 }
 
 TEST_F(QuicPacketSchedulerTest, StreamFrameNoSpace) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.streamManager->setMaxLocalBidirectionalStreams(10);
   auto connId = getTestConnectionId();
   auto stream = conn.streamManager->createNextBidirectionalStream().value();
@@ -407,7 +413,8 @@ TEST_F(QuicPacketSchedulerTest, StreamFrameNoSpace) {
 }
 
 TEST_F(QuicPacketSchedulerTest, StreamFrameSchedulerStreamNotExists) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   auto connId = getTestConnectionId();
   StreamId nonExistentStream = 11;
 

quic/api/test/QuicTransportBaseTest.cpp

@@ -15,6 +15,7 @@
 #include <quic/api/QuicTransportBase.h>
 #include <quic/codec/DefaultConnectionIdAlgo.h>
 #include <quic/common/test/TestUtils.h>
+#include <quic/fizz/server/handshake/FizzServerQuicHandshakeContext.h>
 #include <quic/server/state/ServerStateMachine.h>
 #include <quic/state/QuicStreamFunctions.h>
 #include <quic/state/test/Mocks.h>
@@ -156,7 +157,8 @@ class TestQuicTransport
       ConnectionCallback& cb)
       : QuicTransportBase(evb, std::move(socket)) {
     setConnectionCallback(&cb);
-    auto conn = std::make_unique<QuicServerConnectionState>();
+    auto conn = std::make_unique<QuicServerConnectionState>(
+        std::make_shared<FizzServerQuicHandshakeContext>());
     conn->clientConnectionId = ConnectionId({10, 9, 8, 7});
     conn->version = QuicVersion::MVFST;
     transportConn = conn.get();

quic/api/test/QuicTransportFunctionsTest.cpp

@@ -11,6 +11,7 @@
 #include <folly/io/async/test/MockAsyncUDPSocket.h>
 #include <quic/api/test/Mocks.h>
 #include <quic/common/test/TestUtils.h>
+#include <quic/fizz/server/handshake/FizzServerQuicHandshakeContext.h>
 #include <quic/logging/FileQLogger.h>
 #include <quic/logging/QLoggerConstants.h>
 #include <quic/server/state/ServerStateMachine.h>
@@ -149,7 +150,8 @@ class QuicTransportFunctionsTest : public Test {
   }
 
   std::unique_ptr<QuicServerConnectionState> createConn() {
-    auto conn = std::make_unique<QuicServerConnectionState>();
+    auto conn = std::make_unique<QuicServerConnectionState>(
+        std::make_shared<FizzServerQuicHandshakeContext>());
     conn->serverConnectionId = getTestConnectionId();
     conn->clientConnectionId = getTestConnectionId();
     conn->version = QuicVersion::MVFST;
@@ -1555,7 +1557,8 @@ TEST_F(QuicTransportFunctionsTest, WriteProbingOldData) {
 }
 
 TEST_F(QuicTransportFunctionsTest, WriteProbingCryptoData) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.serverConnectionId = getTestConnectionId();
   conn.clientConnectionId = getTestConnectionId();
   // writeCryptoDataProbesToSocketForTest writes Initial LongHeader, thus it

quic/api/test/TestQuicTransport.h

@@ -11,6 +11,7 @@
 #include <quic/api/QuicTransportBase.h>
 #include <quic/api/QuicTransportFunctions.h>
 #include <quic/common/test/TestUtils.h>
+#include <quic/fizz/server/handshake/FizzServerQuicHandshakeContext.h>
 
 namespace quic {
 
@@ -24,7 +25,8 @@ class TestQuicTransport
       ConnectionCallback& cb)
       : QuicTransportBase(evb, std::move(socket)) {
     setConnectionCallback(&cb);
-    conn_.reset(new QuicServerConnectionState());
+    conn_.reset(new QuicServerConnectionState(
+        std::make_shared<FizzServerQuicHandshakeContext>()));
     conn_->clientConnectionId = ConnectionId({9, 8, 7, 6});
     conn_->serverConnectionId = ConnectionId({1, 2, 3, 4});
     conn_->version = QuicVersion::MVFST;

quic/codec/test/QuicPacketRebuilderTest.cpp

@@ -12,6 +12,7 @@
 #include <quic/codec/QuicPacketRebuilder.h>
 #include <quic/codec/test/Mocks.h>
 #include <quic/common/test/TestUtils.h>
+#include <quic/fizz/server/handshake/FizzServerQuicHandshakeContext.h>
 #include <quic/server/state/ServerStateMachine.h>
 #include <quic/state/QuicStateFunctions.h>
 #include <quic/state/QuicStreamFunctions.h>
@@ -64,7 +65,8 @@ TEST_F(QuicPacketRebuilderTest, RebuildPacket) {
   ackBlocks.insert(10, 100);
   ackBlocks.insert(200, 1000);
   AckFrameMetaData ackMeta(ackBlocks, 0us, kDefaultAckDelayExponent);
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.streamManager->setMaxLocalBidirectionalStreams(10);
   auto stream = conn.streamManager->createNextBidirectionalStream().value();
   auto streamId = stream->id;
@@ -201,7 +203,8 @@ TEST_F(QuicPacketRebuilderTest, RebuildAfterResetStream) {
   RegularQuicPacketBuilder regularBuilder1(
       kDefaultUDPSendPacketLen, std::move(shortHeader1), 0 /* largestAcked */);
   regularBuilder1.encodePacketHeader();
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.streamManager->setMaxLocalBidirectionalStreams(10);
   auto stream = conn.streamManager->createNextBidirectionalStream().value();
   auto streamId = stream->id;
@@ -237,7 +240,8 @@ TEST_F(QuicPacketRebuilderTest, FinOnlyStreamRebuild) {
   RegularQuicPacketBuilder regularBuilder1(
       kDefaultUDPSendPacketLen, std::move(shortHeader1), 0 /* largestAcked */);
   regularBuilder1.encodePacketHeader();
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.streamManager->setMaxLocalBidirectionalStreams(10);
   auto stream = conn.streamManager->createNextBidirectionalStream().value();
   auto streamId = stream->id;
@@ -281,7 +285,8 @@ TEST_F(QuicPacketRebuilderTest, RebuildDataStreamAndEmptyCryptoStream) {
       kDefaultUDPSendPacketLen, std::move(shortHeader1), 0 /* largestAcked */);
   regularBuilder1.encodePacketHeader();
   // Get a bunch frames
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.streamManager->setMaxLocalBidirectionalStreams(10);
   auto stream = conn.streamManager->createNextBidirectionalStream().value();
   StreamId streamId = stream->id;
@@ -344,7 +349,8 @@ TEST_F(QuicPacketRebuilderTest, CannotRebuildEmptyCryptoStream) {
       kDefaultUDPSendPacketLen, std::move(shortHeader1), 0 /* largestAcked */);
   regularBuilder1.encodePacketHeader();
   // Get a bunch frames
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   uint64_t cryptoOffset = 0;
   auto cryptoBuf = folly::IOBuf::copyBuffer("NewSessionTicket");
 
@@ -382,7 +388,8 @@ TEST_F(QuicPacketRebuilderTest, CannotRebuild) {
   ackBlocks.insert(10, 100);
   ackBlocks.insert(200, 1000);
   AckFrameMetaData ackMeta(ackBlocks, 0us, kDefaultAckDelayExponent);
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.streamManager->setMaxLocalBidirectionalStreams(10);
   auto stream = conn.streamManager->createNextBidirectionalStream().value();
   auto streamId = stream->id;
@@ -437,7 +444,8 @@ TEST_F(QuicPacketRebuilderTest, CloneCounter) {
   writeFrame(maxDataFrame, regularBuilder);
   auto packet = std::move(regularBuilder).buildPacket();
   auto outstandingPacket = makeDummyOutstandingPacket(packet.packet, 1000);
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   ShortHeader shortHeader2(
       ProtectionType::KeyPhaseZero, getTestConnectionId(), 0);
   RegularQuicPacketBuilder regularBuilder2(
@@ -460,7 +468,8 @@ TEST_F(QuicPacketRebuilderTest, PurePingWontRebuild) {
   auto packet = std::move(regularBuilder).buildPacket();
   auto outstandingPacket = makeDummyOutstandingPacket(packet.packet, 50);
   EXPECT_EQ(1, outstandingPacket.packet.frames.size());
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   ShortHeader shortHeader2(
       ProtectionType::KeyPhaseZero, getTestConnectionId(), 0);
   RegularQuicPacketBuilder regularBuilder2(
@@ -473,7 +482,8 @@ TEST_F(QuicPacketRebuilderTest, PurePingWontRebuild) {
 }
 
 TEST_F(QuicPacketRebuilderTest, LastStreamFrameSkipLen) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.streamManager->setMaxLocalBidirectionalStreams(100);
   auto stream = conn.streamManager->createNextBidirectionalStream().value();
   auto streamId = stream->id;
@@ -547,7 +557,8 @@ TEST_F(QuicPacketRebuilderTest, LastStreamFrameSkipLen) {
 }
 
 TEST_F(QuicPacketRebuilderTest, LastStreamFrameFinOnlyNotSkipLen) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.streamManager->setMaxLocalBidirectionalStreams(100);
   auto stream = conn.streamManager->createNextBidirectionalStream().value();
   auto streamId = stream->id;

quic/congestion_control/test/CopaTest.cpp

@@ -10,6 +10,7 @@
 
 #include <folly/portability/GTest.h>
 #include <quic/common/test/TestUtils.h>
+#include <quic/fizz/server/handshake/FizzServerQuicHandshakeContext.h>
 #include <quic/state/test/Mocks.h>
 
 using namespace testing;
@@ -129,7 +130,8 @@ class CopaTest : public Test {
 };
 
 TEST_F(CopaTest, TestWritableBytes) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.transportSettings.copaDeltaParam = 0.5;
   Copa copa(conn);
   EXPECT_TRUE(copa.inSlowStart());
@@ -145,7 +147,8 @@ TEST_F(CopaTest, TestWritableBytes) {
 }
 
 TEST_F(CopaTest, PersistentCongestion) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.transportSettings.copaDeltaParam = 0.5;
   Copa copa(conn);
   auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
@@ -178,7 +181,8 @@ TEST_F(CopaTest, PersistentCongestion) {
 }
 
 TEST_F(CopaTest, RemoveBytesWithoutLossOrAck) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.transportSettings.copaDeltaParam = 0.5;
   Copa copa(conn);
   auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
@@ -210,7 +214,8 @@ TEST_F(CopaTest, RemoveBytesWithoutLossOrAck) {
 }
 
 TEST_F(CopaTest, TestSlowStartAck) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.transportSettings.copaDeltaParam = 0.5;
   Copa copa(conn);
   auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
@@ -312,7 +317,8 @@ TEST_F(CopaTest, TestSlowStartAck) {
 }
 
 TEST_F(CopaTest, TestSteadyStateChanges) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.transportSettings.copaDeltaParam = 0.5;
   Copa copa(conn);
   auto now = Clock::now();
@@ -349,7 +355,8 @@ TEST_F(CopaTest, TestSteadyStateChanges) {
 }
 
 TEST_F(CopaTest, TestVelocity) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.transportSettings.copaDeltaParam = 0.5;
   conn.transportSettings.pacingTimerTickInterval = 10ms;
   Copa copa(conn);
@@ -444,7 +451,8 @@ TEST_F(CopaTest, TestVelocity) {
 }
 
 TEST_F(CopaTest, NoLargestAckedPacketNoCrash) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.transportSettings.copaDeltaParam = 0.5;
   Copa copa(conn);
   auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
@@ -465,7 +473,8 @@ TEST_F(CopaTest, NoLargestAckedPacketNoCrash) {
 }
 
 TEST_F(CopaTest, PacketLossInvokesPacer) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.transportSettings.copaDeltaParam = 0.5;
   Copa copa(conn);
   auto mockPacer = std::make_unique<MockPacer>();

quic/congestion_control/test/NewRenoTest.cpp

@@ -10,6 +10,7 @@
 
 #include <folly/portability/GTest.h>
 #include <quic/common/test/TestUtils.h>
+#include <quic/fizz/server/handshake/FizzServerQuicHandshakeContext.h>
 
 using namespace testing;
 
@@ -58,7 +59,8 @@ createPacket(PacketNum packetNum, uint32_t size, TimePoint sendTime) {
 }
 
 TEST_F(NewRenoTest, TestLoss) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   NewReno reno(conn);
   EXPECT_TRUE(reno.inSlowStart());
 
@@ -97,7 +99,8 @@ TEST_F(NewRenoTest, TestLoss) {
 }
 
 TEST_F(NewRenoTest, SendMoreThanWritable) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   NewReno reno(conn);
   EXPECT_TRUE(reno.inSlowStart());
 
@@ -114,7 +117,8 @@ TEST_F(NewRenoTest, SendMoreThanWritable) {
 }
 
 TEST_F(NewRenoTest, TestSlowStartAck) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   NewReno reno(conn);
   EXPECT_TRUE(reno.inSlowStart());
 
@@ -134,7 +138,8 @@ TEST_F(NewRenoTest, TestSlowStartAck) {
 }
 
 TEST_F(NewRenoTest, TestSteadyStateAck) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   NewReno reno(conn);
   EXPECT_TRUE(reno.inSlowStart());
 
@@ -175,7 +180,8 @@ TEST_F(NewRenoTest, TestSteadyStateAck) {
 }
 
 TEST_F(NewRenoTest, TestWritableBytes) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   NewReno reno(conn);
   EXPECT_TRUE(reno.inSlowStart());
 
@@ -190,7 +196,8 @@ TEST_F(NewRenoTest, TestWritableBytes) {
 }
 
 TEST_F(NewRenoTest, PersistentCongestion) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   NewReno reno(conn);
   EXPECT_TRUE(reno.inSlowStart());
 
@@ -210,7 +217,8 @@ TEST_F(NewRenoTest, PersistentCongestion) {
 }
 
 TEST_F(NewRenoTest, RemoveBytesWithoutLossOrAck) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   NewReno reno(conn);
   EXPECT_TRUE(reno.inSlowStart());
 

quic/fizz/server/handshake/FizzServerHandshake.cpp

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+#include <quic/fizz/server/handshake/FizzServerHandshake.h>
+
+// This is necessary for the conversion between QuicServerConnectionState and
+// QuicConnectionStateBase and can be removed once ServerHandshake accepts
+// QuicServerConnectionState.
+#include <quic/server/state/ServerStateMachine.h>
+
+namespace quic {
+
+FizzServerHandshake::FizzServerHandshake(
+    QuicServerConnectionState* conn,
+    std::shared_ptr<FizzServerQuicHandshakeContext> fizzContext)
+    : ServerHandshake(conn), fizzContext_(std::move(fizzContext)) {}
+
+} // namespace quic

quic/fizz/server/handshake/FizzServerHandshake.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+#pragma once
+
+#include <quic/server/handshake/ServerHandshake.h>
+
+namespace quic {
+
+class FizzServerQuicHandshakeContext;
+struct QuicServerConnectionState;
+
+class FizzServerHandshake : public ServerHandshake {
+ public:
+  FizzServerHandshake(
+      QuicServerConnectionState* conn,
+      std::shared_ptr<FizzServerQuicHandshakeContext> fizzContext);
+
+ private:
+  std::shared_ptr<FizzServerQuicHandshakeContext> fizzContext_;
+};
+
+} // namespace quic

quic/fizz/server/handshake/FizzServerQuicHandshakeContext.cpp

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+#include <quic/fizz/server/handshake/FizzServerQuicHandshakeContext.h>
+
+#include <quic/fizz/server/handshake/FizzServerHandshake.h>
+
+namespace quic {
+
+std::unique_ptr<ServerHandshake>
+FizzServerQuicHandshakeContext::makeServerHandshake(
+    QuicServerConnectionState* conn) {
+  return std::make_unique<FizzServerHandshake>(conn, shared_from_this());
+}
+
+} // namespace quic

quic/fizz/server/handshake/FizzServerQuicHandshakeContext.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+#pragma once
+
+#include <quic/server/handshake/ServerHandshakeFactory.h>
+
+namespace quic {
+
+class FizzServerHandshake;
+
+class FizzServerQuicHandshakeContext
+    : public ServerHandshakeFactory,
+      public std::enable_shared_from_this<FizzServerQuicHandshakeContext> {
+ public:
+  std::unique_ptr<ServerHandshake> makeServerHandshake(
+      QuicServerConnectionState* conn) override;
+};
+
+} // namespace quic

quic/loss/test/QuicLossFunctionsTest.cpp

@@ -16,6 +16,7 @@
 #include <quic/codec/DefaultConnectionIdAlgo.h>
 #include <quic/common/test/TestUtils.h>
 #include <quic/fizz/client/handshake/FizzClientQuicHandshakeContext.h>
+#include <quic/fizz/server/handshake/FizzServerQuicHandshakeContext.h>
 #include <quic/logging/test/Mocks.h>
 #include <quic/loss/QuicLossFunctions.h>
 #include <quic/server/state/ServerStateMachine.h>
@@ -60,7 +61,8 @@ class QuicLossFunctionsTest : public TestWithParam<PacketNumberSpace> {
       PacketType packetType);
 
   std::unique_ptr<QuicServerConnectionState> createConn() {
-    auto conn = std::make_unique<QuicServerConnectionState>();
+    auto conn = std::make_unique<QuicServerConnectionState>(
+        std::make_shared<FizzServerQuicHandshakeContext>());
     conn->clientConnectionId = getTestConnectionId();
     conn->version = QuicVersion::MVFST;
     conn->ackStates.initialAckState.nextPacketNum = 1;

quic/server/CMakeLists.txt

@@ -17,6 +17,10 @@ add_library(
   handshake/DefaultAppTokenValidator.cpp
   handshake/StatelessResetGenerator.cpp
   state/ServerStateMachine.cpp
+
+  # Fizz specific parts, will be split in its own lib eventually.
+  ../fizz/server/handshake/FizzServerQuicHandshakeContext.cpp
+  ../fizz/server/handshake/FizzServerHandshake.cpp
 )
 
 target_include_directories(

quic/server/QuicServerTransport.cpp

@@ -8,9 +8,11 @@
 
 #include <quic/server/QuicServerTransport.h>
 
+#include <quic/fizz/server/handshake/FizzServerQuicHandshakeContext.h>
 #include <quic/server/handshake/AppToken.h>
 #include <quic/server/handshake/DefaultAppTokenValidator.h>
 #include <quic/server/handshake/StatelessResetGenerator.h>
+
 #include <algorithm>
 
 namespace quic {
@@ -21,7 +23,8 @@ QuicServerTransport::QuicServerTransport(
     ConnectionCallback& cb,
     std::shared_ptr<const fizz::server::FizzServerContext> ctx)
     : QuicTransportBase(evb, std::move(sock)), ctx_(std::move(ctx)) {
-  auto tempConn = std::make_unique<QuicServerConnectionState>();
+  auto tempConn = std::make_unique<QuicServerConnectionState>(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   tempConn->serverAddr = socket_->address();
   serverConn_ = tempConn.get();
   conn_.reset(tempConn.release());

quic/server/handshake/ServerHandshakeFactory.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+#pragma once
+
+#include <memory>
+
+namespace quic {
+
+class ServerHandshake;
+struct QuicServerConnectionState;
+
+class ServerHandshakeFactory {
+ public:
+  virtual ~ServerHandshakeFactory() = default;
+
+  /**
+   * Construct a new server handshake.
+   */
+  virtual std::unique_ptr<ServerHandshake> makeServerHandshake(
+      QuicServerConnectionState* conn) = 0;
+};
+
+} // namespace quic

quic/server/handshake/test/DefaultAppTokenValidatorTest.cpp

@@ -10,6 +10,7 @@
 
 #include <quic/QuicConstants.h>
 #include <quic/api/test/Mocks.h>
+#include <quic/fizz/server/handshake/FizzServerQuicHandshakeContext.h>
 #include <quic/server/state/ServerStateMachine.h>
 
 #include <fizz/server/ResumptionState.h>
@@ -25,7 +26,8 @@ namespace quic {
 namespace test {
 
 TEST(DefaultAppTokenValidatorTest, TestValidParams) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.peerAddress = folly::SocketAddress("1.2.3.4", 443);
   conn.version = QuicVersion::MVFST;
   conn.transportSettings.zeroRttSourceTokenMatchingPolicy =
@@ -53,7 +55,8 @@ TEST(DefaultAppTokenValidatorTest, TestValidParams) {
 TEST(
     DefaultAppTokenValidatorTest,
     TestValidUnequalParamsUpdateTransportSettings) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.peerAddress = folly::SocketAddress("1.2.3.4", 443);
   conn.version = QuicVersion::MVFST;
   conn.transportSettings.zeroRttSourceTokenMatchingPolicy =
@@ -87,7 +90,8 @@ TEST(
 }
 
 TEST(DefaultAppTokenValidatorTest, TestInvalidNullAppToken) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.peerAddress = folly::SocketAddress("1.2.3.4", 443);
   conn.version = QuicVersion::MVFST;
 
@@ -102,7 +106,8 @@ TEST(DefaultAppTokenValidatorTest, TestInvalidNullAppToken) {
 }
 
 TEST(DefaultAppTokenValidatorTest, TestInvalidEmptyTransportParams) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.peerAddress = folly::SocketAddress("1.2.3.4", 443);
   conn.version = QuicVersion::MVFST;
 
@@ -120,7 +125,8 @@ TEST(DefaultAppTokenValidatorTest, TestInvalidEmptyTransportParams) {
 }
 
 TEST(DefaultAppTokenValidatorTest, TestInvalidMissingParams) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.peerAddress = folly::SocketAddress("1.2.3.4", 443);
   conn.version = QuicVersion::MVFST;
 
@@ -155,7 +161,8 @@ TEST(DefaultAppTokenValidatorTest, TestInvalidMissingParams) {
 }
 
 TEST(DefaultAppTokenValidatorTest, TestInvalidRedundantParameter) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.peerAddress = folly::SocketAddress("1.2.3.4", 443);
   conn.version = QuicVersion::MVFST;
 
@@ -184,7 +191,8 @@ TEST(DefaultAppTokenValidatorTest, TestInvalidRedundantParameter) {
 }
 
 TEST(DefaultAppTokenValidatorTest, TestInvalidDecreasedInitialMaxStreamData) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.peerAddress = folly::SocketAddress("1.2.3.4", 443);
   conn.version = QuicVersion::MVFST;
 
@@ -211,7 +219,8 @@ TEST(DefaultAppTokenValidatorTest, TestInvalidDecreasedInitialMaxStreamData) {
 }
 
 TEST(DefaultAppTokenValidatorTest, TestChangedIdleTimeout) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.peerAddress = folly::SocketAddress("1.2.3.4", 443);
   conn.version = QuicVersion::MVFST;
 
@@ -238,7 +247,8 @@ TEST(DefaultAppTokenValidatorTest, TestChangedIdleTimeout) {
 }
 
 TEST(DefaultAppTokenValidatorTest, TestDecreasedInitialMaxStreams) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.peerAddress = folly::SocketAddress("1.2.3.4", 443);
   conn.version = QuicVersion::MVFST;
 
@@ -265,7 +275,8 @@ TEST(DefaultAppTokenValidatorTest, TestDecreasedInitialMaxStreams) {
 }
 
 TEST(DefaultAppTokenValidatorTest, TestInvalidAppParams) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.peerAddress = folly::SocketAddress("1.2.3.4", 443);
   conn.version = QuicVersion::MVFST;
 
@@ -292,6 +303,9 @@ TEST(DefaultAppTokenValidatorTest, TestInvalidAppParams) {
 
 class SourceAddressTokenTest : public Test {
  public:
+  SourceAddressTokenTest()
+      : conn_(std::make_shared<FizzServerQuicHandshakeContext>()) {}
+
   void SetUp() override {
     conn_.peerAddress = folly::SocketAddress("1.2.3.4", 443);
     conn_.version = QuicVersion::MVFST;

quic/server/handshake/test/ServerHandshakeTest.cpp

@@ -28,6 +28,7 @@
 #include <quic/fizz/client/handshake/FizzClientExtensions.h>
 #include <quic/fizz/handshake/FizzBridge.h>
 #include <quic/fizz/handshake/QuicFizzFactory.h>
+#include <quic/fizz/server/handshake/FizzServerQuicHandshakeContext.h>
 #include <quic/handshake/HandshakeLayer.h>
 #include <quic/server/handshake/AppToken.h>
 #include <quic/server/handshake/ServerHandshake.h>
@@ -49,7 +50,9 @@ class MockServerHandshakeCallback : public ServerHandshake::HandshakeCallback {
 };
 
 struct TestingServerConnectionState : public QuicServerConnectionState {
-  explicit TestingServerConnectionState() : QuicServerConnectionState() {}
+  explicit TestingServerConnectionState()
+      : QuicServerConnectionState(
+            std::make_shared<FizzServerQuicHandshakeContext>()) {}
 
   uint32_t getDestructorGuardCount() const {
     return folly::DelayedDestruction::getDestructorGuardCount();

quic/server/state/ServerStateMachine.h

@@ -20,6 +20,7 @@
 #include <quic/logging/QuicLogger.h>
 #include <quic/loss/QuicLossFunctions.h>
 #include <quic/server/handshake/ServerHandshake.h>
+#include <quic/server/handshake/ServerHandshakeFactory.h>
 #include <quic/server/state/ServerConnectionIdRejector.h>
 #include <quic/state/AckHandlers.h>
 #include <quic/state/QPRFunctions.h>
@@ -141,7 +142,9 @@ struct QuicServerConnectionState : public QuicConnectionStateBase {
 
   folly::Optional<ConnectionIdData> createAndAddNewSelfConnId() override;
 
-  QuicServerConnectionState() : QuicConnectionStateBase(QuicNodeType::Server) {
+  QuicServerConnectionState(
+      std::shared_ptr<ServerHandshakeFactory> handshakeFactory)
+      : QuicConnectionStateBase(QuicNodeType::Server) {
     state = ServerState::Open;
     // Create the crypto stream.
     cryptoState = std::make_unique<QuicCryptoState>();
@@ -155,8 +158,10 @@ struct QuicServerConnectionState : public QuicConnectionStateBase {
                                   QuicVersion::QUIC_DRAFT,
                                   QuicVersion::QUIC_DRAFT_LEGACY}};
     originalVersion = QuicVersion::MVFST;
-    serverHandshakeLayer = new ServerHandshake(this);
+    DCHECK(handshakeFactory);
-    handshakeLayer.reset(serverHandshakeLayer);
+    auto tmpServerHandshake = handshakeFactory->makeServerHandshake(this);
+    serverHandshakeLayer = tmpServerHandshake.get();
+    handshakeLayer = std::move(tmpServerHandshake);
     // We shouldn't normally need to set this until we're starting the
     // transport, however writing unit tests is much easier if we set this here.
     updateFlowControlStateWithSettings(flowControlState, transportSettings);

quic/server/test/CMakeLists.txt

@@ -27,7 +27,6 @@ quic_add_test(TARGET QuicServerTransportTest
   Folly::folly
   mvfst_codec_pktbuilder
   mvfst_codec_types
-  mvfst_fizz_handshake
   mvfst_server
   mvfst_state_stream_functions
   mvfst_test_utils

quic/server/test/ServerStateMachineTest.cpp

@@ -9,6 +9,7 @@
 #include <quic/codec/QuicConnectionId.h>
 #include <quic/codec/test/Mocks.h>
 #include <quic/common/test/TestUtils.h>
+#include <quic/fizz/server/handshake/FizzServerQuicHandshakeContext.h>
 #include <quic/server/test/Mocks.h>
 
 using namespace testing;
@@ -28,7 +29,8 @@ void assertServerConnIdParamsEq(
 
 namespace test {
 TEST(ServerStateMachineTest, TestAddConnId) {
-  QuicServerConnectionState serverState;
+  QuicServerConnectionState serverState(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   ServerConnectionIdParams originalParams(12, 1, 37);
 
   auto algo = std::make_unique<DefaultConnectionIdAlgo>();
@@ -73,7 +75,8 @@ TEST(ServerStateMachineTest, TestAddConnId) {
 }
 
 TEST(ServerStateMachineTest, TestCidRejected) {
-  QuicServerConnectionState serverConn;
+  QuicServerConnectionState serverConn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   MockServerConnectionIdRejector mockRejector;
   ServerConnectionIdParams serverCidParams(10, 11, 12);
   MockConnectionIdAlgo mockCidAlgo;
@@ -104,7 +107,8 @@ TEST(ServerStateMachineTest, TestCidRejected) {
 }
 
 TEST(ServerStateMachineTest, TestCidRejectedThenFail) {
-  QuicServerConnectionState serverConn;
+  QuicServerConnectionState serverConn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   MockServerConnectionIdRejector mockRejector;
   ServerConnectionIdParams serverCidParams(10, 11, 12);
   MockConnectionIdAlgo mockCidAlgo;
@@ -131,7 +135,8 @@ TEST(ServerStateMachineTest, TestCidRejectedThenFail) {
 }
 
 TEST(ServerStateMachineTest, TestCidRejectedGiveUp) {
-  QuicServerConnectionState serverConn;
+  QuicServerConnectionState serverConn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   MockServerConnectionIdRejector mockRejector;
   ServerConnectionIdParams serverCidParams(10, 11, 12);
   MockConnectionIdAlgo mockCidAlgo;

quic/state/stream/test/StreamStateFunctionsTest.cpp

@@ -9,6 +9,7 @@
 #include <quic/state/stream/StreamStateFunctions.h>
 #include <gtest/gtest.h>
 #include <quic/common/test/TestUtils.h>
+#include <quic/fizz/server/handshake/FizzServerQuicHandshakeContext.h>
 #include <quic/logging/FileQLogger.h>
 #include <quic/server/state/ServerStateMachine.h>
 #include <quic/state/QuicStreamFunctions.h>
@@ -22,7 +23,8 @@ namespace test {
 class StreamStateFunctionsTests : public Test {};
 
 TEST_F(StreamStateFunctionsTests, BasicResetTest) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   StreamId streamId = 0xbaad;
   QuicStreamState stream(streamId, conn);
   appendDataToReadBuffer(
@@ -55,14 +57,16 @@ TEST_F(StreamStateFunctionsTests, BasicResetTest) {
 }
 
 TEST_F(StreamStateFunctionsTests, IsAllDataReceivedEmptyStream) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   StreamId id = 3;
   QuicStreamState stream(id, conn);
   EXPECT_FALSE(isAllDataReceived(stream));
 }
 
 TEST_F(StreamStateFunctionsTests, IsAllDataReceivedReadBufferHasHole) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   StreamId id = 3;
   QuicStreamState stream(id, conn);
   stream.currentReadOffset = 100;
@@ -74,7 +78,8 @@ TEST_F(StreamStateFunctionsTests, IsAllDataReceivedReadBufferHasHole) {
 }
 
 TEST_F(StreamStateFunctionsTests, IsAllDataReceivedReadBufferNoHoleNoFin) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   StreamId id = 3;
   QuicStreamState stream(id, conn);
   stream.currentReadOffset = 100;
@@ -85,7 +90,8 @@ TEST_F(StreamStateFunctionsTests, IsAllDataReceivedReadBufferNoHoleNoFin) {
 }
 
 TEST_F(StreamStateFunctionsTests, IsAllDataReceivedReadBufferEmptyBufferFin) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   StreamId id = 3;
   QuicStreamState stream(id, conn);
   stream.currentReadOffset = 100;
@@ -95,7 +101,8 @@ TEST_F(StreamStateFunctionsTests, IsAllDataReceivedReadBufferEmptyBufferFin) {
 }
 
 TEST_F(StreamStateFunctionsTests, IsAllDataReceivedReadBufferBufferFin) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   StreamId id = 3;
   QuicStreamState stream(id, conn);
   stream.currentReadOffset = 100;
@@ -107,7 +114,8 @@ TEST_F(StreamStateFunctionsTests, IsAllDataReceivedReadBufferBufferFin) {
 }
 
 TEST_F(StreamStateFunctionsTests, IsAllDataReceivedMultipleStreamDataNoHole) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   StreamId id = 3;
   QuicStreamState stream(id, conn);
   stream.currentReadOffset = 100;
@@ -123,7 +131,8 @@ TEST_F(StreamStateFunctionsTests, IsAllDataReceivedMultipleStreamDataNoHole) {
 }
 
 TEST_F(StreamStateFunctionsTests, IsAllDataReceivedMultipleStreamDataHasHole) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   StreamId id = 3;
   QuicStreamState stream(id, conn);
   stream.currentReadOffset = 100;
@@ -139,7 +148,8 @@ TEST_F(StreamStateFunctionsTests, IsAllDataReceivedMultipleStreamDataHasHole) {
 }
 
 TEST_F(StreamStateFunctionsTests, IsAllDataReceivedAllDataRead) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   StreamId id = 3;
   QuicStreamState stream(id, conn);
   stream.currentReadOffset = 101;
@@ -148,7 +158,8 @@ TEST_F(StreamStateFunctionsTests, IsAllDataReceivedAllDataRead) {
 }
 
 TEST_F(StreamStateFunctionsTests, SendReset) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   StreamId id = 1;
   QuicStreamState stream(id, conn);
   writeDataToQuicStream(stream, folly::IOBuf::copyBuffer("hello"), true);
@@ -163,7 +174,8 @@ TEST_F(StreamStateFunctionsTests, SendReset) {
 }
 
 TEST_F(StreamStateFunctionsTests, ResetNoFlowControlGenerated) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   StreamId id = 1;
   QuicStreamState stream(id, conn);
   writeDataToQuicStream(stream, folly::IOBuf::copyBuffer("hello"), true);
@@ -186,7 +198,8 @@ TEST_F(StreamStateFunctionsTests, ResetNoFlowControlGenerated) {
 }
 
 TEST_F(StreamStateFunctionsTests, ResetFlowControlGenerated) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
   conn.qLogger = qLogger;
 
@@ -221,7 +234,8 @@ TEST_F(StreamStateFunctionsTests, ResetFlowControlGenerated) {
 }
 
 TEST_F(StreamStateFunctionsTests, ResetOffsetNotMatch) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   StreamId id = 1;
   QuicStreamState stream(id, conn);
   RstStreamFrame rst(id, GenericApplicationErrorCode::UNKNOWN, 10);
@@ -234,7 +248,8 @@ TEST_F(StreamStateFunctionsTests, ResetOffsetNotMatch) {
 }
 
 TEST_F(StreamStateFunctionsTests, ResetOffsetLessThanMaxObserved) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   StreamId id = 1;
   QuicStreamState stream(id, conn);
   RstStreamFrame rst(id, GenericApplicationErrorCode::UNKNOWN, 30);
@@ -246,7 +261,8 @@ TEST_F(StreamStateFunctionsTests, ResetOffsetLessThanMaxObserved) {
 }
 
 TEST_F(StreamStateFunctionsTests, ResetOffsetGreaterThanStreamFlowControl) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   StreamId id = 1;
   QuicStreamState stream(id, conn);
   RstStreamFrame rst(id, GenericApplicationErrorCode::UNKNOWN, 200);
@@ -258,7 +274,8 @@ TEST_F(StreamStateFunctionsTests, ResetOffsetGreaterThanStreamFlowControl) {
 }
 
 TEST_F(StreamStateFunctionsTests, ResetOffsetGreaterThanConnFlowControl) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   StreamId id = 1;
   QuicStreamState stream(id, conn);
   RstStreamFrame rst(id, GenericApplicationErrorCode::UNKNOWN, 200);
@@ -277,7 +294,8 @@ TEST_F(StreamStateFunctionsTests, ResetOffsetGreaterThanConnFlowControl) {
 }
 
 TEST_F(StreamStateFunctionsTests, ResetAfterReadingAllBytesTillFin) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   StreamId id = 1;
   QuicStreamState stream(id, conn);
   RstStreamFrame rst(id, GenericApplicationErrorCode::UNKNOWN, 100);

quic/state/stream/test/StreamStateMachineTest.cpp

@@ -12,6 +12,7 @@
 #include <quic/api/QuicTransportFunctions.h>
 #include <quic/codec/DefaultConnectionIdAlgo.h>
 #include <quic/common/test/TestUtils.h>
+#include <quic/fizz/server/handshake/FizzServerQuicHandshakeContext.h>
 #include <quic/state/QuicStreamFunctions.h>
 #include <quic/state/stream/StreamReceiveHandlers.h>
 #include <quic/state/stream/StreamSendHandlers.h>
@@ -31,7 +32,8 @@ void verifyStreamReset(
 }
 
 std::unique_ptr<QuicServerConnectionState> createConn() {
-  auto conn = std::make_unique<QuicServerConnectionState>();
+  auto conn = std::make_unique<QuicServerConnectionState>(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn->clientConnectionId = getTestConnectionId();
   conn->version = QuicVersion::MVFST;
   conn->ackStates.initialAckState.nextPacketNum = 1;

quic/state/test/AckHandlersTest.cpp

@@ -11,6 +11,7 @@
 
 #include <quic/common/test/TestUtils.h>
 
+#include <quic/fizz/server/handshake/FizzServerQuicHandshakeContext.h>
 #include <quic/logging/test/Mocks.h>
 #include <quic/server/state/ServerStateMachine.h>
 #include <quic/state/AckHandlers.h>
@@ -35,7 +36,8 @@ auto testLossHandler(std::vector<PacketNum>& lostPackets) -> decltype(auto) {
 }
 
 TEST_P(AckHandlersTest, TestAckMultipleSequentialBlocks) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.lossState.reorderingThreshold = 85;
   auto mockCongestionController = std::make_unique<MockCongestionController>();
   auto rawCongestionController = mockCongestionController.get();
@@ -105,7 +107,8 @@ TEST_P(AckHandlersTest, TestAckMultipleSequentialBlocks) {
 }
 
 TEST_P(AckHandlersTest, TestAckMultipleSequentialBlocksLoss) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.lossState.reorderingThreshold = 85;
   auto mockCongestionController = std::make_unique<MockCongestionController>();
   auto rawCongestionController = mockCongestionController.get();
@@ -241,7 +244,8 @@ TEST_P(AckHandlersTest, TestAckMultipleSequentialBlocksLoss) {
 }
 
 TEST_P(AckHandlersTest, TestAckBlocksWithGaps) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.lossState.reorderingThreshold = 30;
   auto mockCongestionController = std::make_unique<MockCongestionController>();
   auto rawCongestionController = mockCongestionController.get();
@@ -338,7 +342,8 @@ TEST_P(AckHandlersTest, TestAckBlocksWithGaps) {
 }
 
 TEST_P(AckHandlersTest, TestNonSequentialPacketNumbers) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.lossState.reorderingThreshold = 10;
   auto mockCongestionController = std::make_unique<MockCongestionController>();
   auto rawCongestionController = mockCongestionController.get();
@@ -431,7 +436,8 @@ TEST_P(AckHandlersTest, TestNonSequentialPacketNumbers) {
 }
 
 TEST_P(AckHandlersTest, AckVisitorForAckTest) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.connectionTime = Clock::now();
   auto firstPacket = createNewPacket(100 /* packetNum */, GetParam());
   WriteAckFrame firstAckFrame;
@@ -506,7 +512,8 @@ TEST_P(AckHandlersTest, AckVisitorForAckTest) {
 }
 
 TEST_P(AckHandlersTest, NoNewAckedPacket) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   auto mockController = std::make_unique<MockCongestionController>();
   auto rawController = mockController.get();
   conn.congestionController = std::move(mockController);
@@ -533,7 +540,8 @@ TEST_P(AckHandlersTest, NoNewAckedPacket) {
 }
 
 TEST_P(AckHandlersTest, LossByAckedRecovered) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   auto mockController = std::make_unique<MockCongestionController>();
   conn.congestionController = std::move(mockController);
 
@@ -550,7 +558,8 @@ TEST_P(AckHandlersTest, LossByAckedRecovered) {
 }
 
 TEST_P(AckHandlersTest, AckPacketNumDoesNotExist) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   auto mockController = std::make_unique<MockCongestionController>();
   conn.congestionController = std::move(mockController);
   // Get the time based loss detection out of the way
@@ -583,7 +592,8 @@ TEST_P(AckHandlersTest, AckPacketNumDoesNotExist) {
 }
 
 TEST_P(AckHandlersTest, TestHandshakeCounterUpdate) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   StreamId stream = 1;
   for (PacketNum packetNum = 0; packetNum < 10; packetNum++) {
     auto regularPacket = createNewPacket(
@@ -641,7 +651,8 @@ TEST_P(AckHandlersTest, TestHandshakeCounterUpdate) {
 }
 
 TEST_P(AckHandlersTest, PurgeAcks) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   WriteAckFrame ackFrame;
   ackFrame.ackBlocks.emplace_back(900, 1000);
   ackFrame.ackBlocks.emplace_back(500, 700);
@@ -659,7 +670,8 @@ TEST_P(AckHandlersTest, PurgeAcks) {
 }
 
 TEST_P(AckHandlersTest, NoSkipAckVisitor) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   auto mockCongestionController = std::make_unique<MockCongestionController>();
   auto rawCongestionController = mockCongestionController.get();
   conn.congestionController = std::move(mockCongestionController);
@@ -702,7 +714,8 @@ TEST_P(AckHandlersTest, NoSkipAckVisitor) {
 }
 
 TEST_P(AckHandlersTest, SkipAckVisitor) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   auto mockCongestionController = std::make_unique<MockCongestionController>();
   auto rawCongestionController = mockCongestionController.get();
   conn.congestionController = std::move(mockCongestionController);
@@ -751,7 +764,8 @@ TEST_P(AckHandlersTest, SkipAckVisitor) {
 }
 
 TEST_P(AckHandlersTest, NoDoubleProcess) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.congestionController.reset();
 
   WriteStreamFrame frame(0, 0, 0, true);
@@ -820,7 +834,8 @@ TEST_P(AckHandlersTest, NoDoubleProcess) {
 }
 
 TEST_P(AckHandlersTest, ClonedPacketsCounter) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.congestionController = nullptr;
   WriteStreamFrame frame(0, 0, 0, true);
   auto packetNum1 = conn.ackStates.appDataAckState.nextPacketNum;
@@ -869,7 +884,8 @@ TEST_P(AckHandlersTest, ClonedPacketsCounter) {
 }
 
 TEST_P(AckHandlersTest, UpdateMaxAckDelay) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.congestionController = nullptr;
   conn.lossState.mrtt = 200us;
   PacketNum packetNum = 0;
@@ -897,7 +913,8 @@ TEST_P(AckHandlersTest, UpdateMaxAckDelay) {
 
 // Ack only acks packets aren't outstanding, but TimeReordering still finds loss
 TEST_P(AckHandlersTest, AckNotOutstandingButLoss) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   auto mockQLogger = std::make_shared<MockQLogger>(VantagePoint::Server);
   conn.qLogger = mockQLogger;
 
@@ -963,7 +980,8 @@ TEST_P(AckHandlersTest, AckNotOutstandingButLoss) {
 }
 
 TEST_P(AckHandlersTest, UpdatePendingAckStates) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.congestionController = nullptr;
   conn.lossState.totalBytesSent = 2468;
   conn.lossState.totalBytesAcked = 1357;
@@ -998,7 +1016,8 @@ TEST_P(AckHandlersTest, UpdatePendingAckStates) {
 }
 
 TEST_P(AckHandlersTest, AckEventCreation) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   auto mockCongestionController = std::make_unique<MockCongestionController>();
   auto rawCongestionController = mockCongestionController.get();
   conn.congestionController = std::move(mockCongestionController);

quic/state/test/QPRFunctionsTest.cpp

@@ -9,6 +9,7 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+#include <quic/fizz/server/handshake/FizzServerQuicHandshakeContext.h>
 #include <quic/server/state/ServerStateMachine.h>
 #include <quic/state/QPRFunctions.h>
 
@@ -20,6 +21,9 @@ namespace test {
 
 class QPRFunctionsTest : public Test {
  public:
+  QPRFunctionsTest()
+      : conn(std::make_shared<FizzServerQuicHandshakeContext>()) {}
+
   void SetUp() override {
     conn.flowControlState.peerAdvertisedInitialMaxStreamOffsetBidiLocal =
         kDefaultStreamWindowSize;

quic/state/test/QuicStateFunctionsTest.cpp

@@ -10,6 +10,7 @@
 #include <gtest/gtest.h>
 
 #include <quic/common/test/TestUtils.h>
+#include <quic/fizz/server/handshake/FizzServerQuicHandshakeContext.h>
 #include <quic/server/state/ServerStateMachine.h>
 #include <quic/state/QuicStateFunctions.h>
 #include <quic/state/stream/StreamReceiveHandlers.h>
@@ -55,7 +56,8 @@ class UpdateLargestReceivedPacketNumTest
     : public TestWithParam<PacketNumberSpace> {};
 
 TEST_P(UpdateLargestReceivedPacketNumTest, ReceiveNew) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   getAckState(conn, GetParam()).largestReceivedPacketNum = 100;
   auto currentLargestReceived =
       *getAckState(conn, GetParam()).largestReceivedPacketNum;
@@ -68,7 +70,8 @@ TEST_P(UpdateLargestReceivedPacketNumTest, ReceiveNew) {
 }
 
 TEST_P(UpdateLargestReceivedPacketNumTest, ReceiveOld) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   getAckState(conn, GetParam()).largestReceivedPacketNum = 100;
   auto currentLargestReceived =
       *getAckState(conn, GetParam()).largestReceivedPacketNum;
@@ -91,7 +94,8 @@ INSTANTIATE_TEST_CASE_P(
 class UpdateAckStateTest : public TestWithParam<PacketNumberSpace> {};
 
 TEST_P(UpdateAckStateTest, TestUpdateAckState) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   PacketNum nextPacketNum = 0;
   auto& ackState = getAckState(conn, GetParam());
   updateAckState(conn, GetParam(), nextPacketNum++, true, false, Clock::now());
@@ -168,7 +172,8 @@ TEST_P(UpdateAckStateTest, TestUpdateAckState) {
 }
 
 TEST_P(UpdateAckStateTest, TestUpdateAckStateFrequency) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.transportSettings.rxPacketsBeforeAckInitThreshold = 20;
   conn.transportSettings.rxPacketsBeforeAckBeforeInit = 2;
   conn.transportSettings.rxPacketsBeforeAckAfterInit = 10;
@@ -367,7 +372,8 @@ INSTANTIATE_TEST_CASE_P(
 class QuicStateFunctionsTest : public TestWithParam<PacketNumberSpace> {};
 
 TEST_F(QuicStateFunctionsTest, RttCalculationNoAckDelay) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   auto rttSample = 1100us;
   updateRtt(conn, rttSample, 0us);
   EXPECT_EQ(1100, conn.lossState.srtt.count());
@@ -376,7 +382,8 @@ TEST_F(QuicStateFunctionsTest, RttCalculationNoAckDelay) {
 }
 
 TEST_F(QuicStateFunctionsTest, RttCalculationWithAckDelay) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   auto rttSample = 1000us;
   updateRtt(conn, rttSample, 300us);
   EXPECT_EQ(700, conn.lossState.srtt.count());
@@ -387,7 +394,8 @@ TEST_F(QuicStateFunctionsTest, RttCalculationWithAckDelay) {
 }
 
 TEST_F(QuicStateFunctionsTest, RttCalculationWithMrttAckDelay) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.lossState.mrtt = 100us;
   auto rttSample = 1000us;
   updateRtt(conn, rttSample, 300us);
@@ -399,7 +407,8 @@ TEST_F(QuicStateFunctionsTest, RttCalculationWithMrttAckDelay) {
 }
 
 TEST_F(QuicStateFunctionsTest, RttCalculationIgnoreAckDelay) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   conn.lossState.mrtt = 700us;
   auto rttSample = 900us;
   updateRtt(conn, rttSample, 300us);
@@ -411,7 +420,8 @@ TEST_F(QuicStateFunctionsTest, RttCalculationIgnoreAckDelay) {
 }
 
 TEST_F(QuicStateFunctionsTest, RttCalculationAckDelayLarger) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   auto rttSample = 10us;
   updateRtt(conn, rttSample, 300us);
   EXPECT_EQ(10, conn.lossState.srtt.count());
@@ -422,7 +432,8 @@ TEST_F(QuicStateFunctionsTest, RttCalculationAckDelayLarger) {
 }
 
 TEST_F(QuicStateFunctionsTest, TestInvokeStreamStateMachineConnectionError) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   QuicStreamState stream(1, conn);
   RstStreamFrame rst(1, GenericApplicationErrorCode::UNKNOWN, 100);
   stream.finalReadOffset = 1024;
@@ -435,7 +446,8 @@ TEST_F(QuicStateFunctionsTest, TestInvokeStreamStateMachineConnectionError) {
 }
 
 TEST_F(QuicStateFunctionsTest, InvokeResetDoesNotSendFlowControl) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   QuicStreamState stream(1, conn);
   RstStreamFrame rst(1, GenericApplicationErrorCode::UNKNOWN, 90);
   // this would normally trigger a flow control update.
@@ -453,7 +465,8 @@ TEST_F(QuicStateFunctionsTest, InvokeResetDoesNotSendFlowControl) {
 TEST_F(QuicStateFunctionsTest, TestInvokeStreamStateMachineStreamError) {
   // We isolate invalid events on streams to affect only the streams. Is that
   // a good idea? We'll find out.
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   QuicStreamState stream(1, conn);
   RstStreamFrame rst(1, GenericApplicationErrorCode::UNKNOWN, 100);
   try {
@@ -467,7 +480,8 @@ TEST_F(QuicStateFunctionsTest, TestInvokeStreamStateMachineStreamError) {
 }
 
 TEST_F(QuicStateFunctionsTest, UpdateMinRtt) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Server);
   conn.qLogger = qLogger;
 
@@ -507,7 +521,8 @@ TEST_F(QuicStateFunctionsTest, UpdateMinRtt) {
 }
 
 TEST_F(QuicStateFunctionsTest, UpdateMaxAckDelay) {
-  QuicServerConnectionState conn;
+  QuicServerConnectionState conn(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   EXPECT_EQ(0us, conn.lossState.maxAckDelay);
   auto rttSample = 100us;
 

quic/state/test/QuicStreamFunctionsTest.cpp

@@ -15,6 +15,7 @@
 #include <quic/client/state/ClientStateMachine.h>
 #include <quic/common/test/TestUtils.h>
 #include <quic/fizz/client/handshake/FizzClientQuicHandshakeContext.h>
+#include <quic/fizz/server/handshake/FizzServerQuicHandshakeContext.h>
 #include <quic/server/state/ServerStateMachine.h>
 
 using namespace folly;
@@ -52,6 +53,9 @@ class QuicStreamFunctionsTest : public Test {
 
 class QuicServerStreamFunctionsTest : public Test {
  public:
+  QuicServerStreamFunctionsTest()
+      : conn(std::make_shared<FizzServerQuicHandshakeContext>()) {}
+
   void SetUp() override {
     conn.flowControlState.peerAdvertisedInitialMaxStreamOffsetBidiLocal =
         kDefaultStreamWindowSize;
@@ -1102,7 +1106,8 @@ TEST_F(QuicStreamFunctionsTest, IsBidirectionalStream) {
 TEST_F(QuicStreamFunctionsTest, IsSendingStream) {
   QuicClientConnectionState clientState(
       FizzClientQuicHandshakeContext::Builder().build());
-  QuicServerConnectionState serverState;
+  QuicServerConnectionState serverState(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   QuicNodeType nodeType;
   StreamId id;
 
@@ -1130,7 +1135,8 @@ TEST_F(QuicStreamFunctionsTest, IsSendingStream) {
 TEST_F(QuicStreamFunctionsTest, IsReceivingStream) {
   QuicClientConnectionState clientState(
       FizzClientQuicHandshakeContext::Builder().build());
-  QuicServerConnectionState serverState;
+  QuicServerConnectionState serverState(
+      std::make_shared<FizzServerQuicHandshakeContext>());
   QuicNodeType nodeType;
   StreamId id;
 

quic/state/test/QuicStreamManagerTest.cpp

@@ -9,6 +9,7 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+#include <quic/fizz/server/handshake/FizzServerQuicHandshakeContext.h>
 #include <quic/server/state/ServerStateMachine.h>
 #include <quic/state/QuicStreamManager.h>
 #include <quic/state/test/Mocks.h>
@@ -20,6 +21,8 @@ namespace test {
 
 class QuicStreamManagerTest : public Test {
  public:
+  QuicStreamManagerTest()
+      : conn(std::make_shared<FizzServerQuicHandshakeContext>()) {}
   void SetUp() override {
     conn.flowControlState.peerAdvertisedInitialMaxStreamOffsetBidiLocal =
         kDefaultStreamWindowSize;