Deprecate old connection callback

Summary: Deprecate old connection callback

Reviewed By: jbeshay, lnicco

Differential Revision: D33695440

fbshipit-source-id: 043baa53b71453b5e2b9f60d890f1adcda7c65b5

quic/api/QuicSocket.h

@@ -139,15 +139,6 @@ class QuicSocket {
     onKnob(uint64_t /*knobSpace*/, uint64_t /*knobId*/, Buf /*knobBlob*/) {}
   };
 
-  /**
-   * Callback for connection level events.  This callback must be set at all
-   * times.
-   * This callback will be phased out with the two separate callbacks above to
-   * replace it.
-   */
-  class ConnectionCallback : public ConnectionSetupCallback,
-                             public ConnectionCallbackNew {};
-
   /**
    * Information about the transport, similar to what TCP has.
    */
@@ -216,11 +207,6 @@ class QuicSocket {
     uint64_t numPacketsTxWithNewData{0};
   };
 
-  /**
-   * Sets connection callback, must be set BEFORE using the socket.
-   */
-  virtual void setConnectionCallback(ConnectionCallback* callback) = 0;
-
   /**
    * Sets connection setup callback. This callback must be set before using the
    * socket.

quic/api/QuicTransportBase.cpp

@@ -28,8 +28,7 @@ namespace quic {
 
 QuicTransportBase::QuicTransportBase(
     folly::EventBase* evb,
-    std::unique_ptr<folly::AsyncUDPSocket> socket,
+    std::unique_ptr<folly::AsyncUDPSocket> socket)
-    bool useSplitConnectionCallbacks)
     : evb_(evb),
       socket_(std::move(socket)),
       lossTimeout_(this),
@@ -52,8 +51,7 @@ QuicTransportBase::QuicTransportBase(
       writeLooper_(new FunctionLooper(
           evb,
           [this](bool fromTimer) { pacedWriteDataToSocket(fromTimer); },
-          LooperType::WriteLooper)),
+          LooperType::WriteLooper)) {
-      useSplitConnectionCallbacks_(useSplitConnectionCallbacks) {
   writeLooper_->setPacingFunction([this]() -> auto {
     if (isConnectionPaced(*conn_)) {
       return conn_->pacer->getTimeUntilNextWrite();
@@ -398,11 +396,7 @@ void QuicTransportBase::closeImpl(
   // connCallback_ could be null if start() was never invoked and the
   // transport was destroyed or if the app initiated close.
   if (connCallback_) {
-    if (!useSplitConnectionCallbacks_) {
+    processConnectionEndErrorSplitCallbacks(cancelCode);
-      processConnectionEndError(cancelCode);
-    } else {
-      processConnectionEndErrorSplitCallbacks(cancelCode);
-    }
   }
 
   // can't invoke connection callbacks any more.
@@ -2706,13 +2700,6 @@ void QuicTransportBase::setSupportedVersions(
   conn_->supportedVersions = versions;
 }
 
-void QuicTransportBase::setConnectionCallback(ConnectionCallback* callback) {
-  if (!connCallback_) {
-    connCallback_ = CallbackDispatcher::make();
-  }
-  connCallback_->setConnectionCallback(CHECK_NOTNULL(callback));
-}
-
 void QuicTransportBase::setConnectionSetupCallback(
     ConnectionSetupCallback* callback) {
   if (!connCallback_) {

quic/api/QuicTransportBase.h

@@ -38,8 +38,7 @@ class QuicTransportBase : public QuicSocket, QuicStreamPrioritiesObserver {
  public:
   QuicTransportBase(
       folly::EventBase* evb,
-      std::unique_ptr<folly::AsyncUDPSocket> socket,
+      std::unique_ptr<folly::AsyncUDPSocket> socket);
-      bool useSplitConnectionCallbacks = false);
 
   ~QuicTransportBase() override;
 
@@ -225,8 +224,6 @@ class QuicTransportBase : public QuicSocket, QuicStreamPrioritiesObserver {
 
   virtual void setSupportedVersions(const std::vector<QuicVersion>& versions);
 
-  void setConnectionCallback(ConnectionCallback* callback) final;
-
   void setConnectionSetupCallback(ConnectionSetupCallback* callback) final;
 
   void setConnectionCallbackNew(ConnectionCallbackNew* callback) final;
@@ -862,7 +859,8 @@ class QuicTransportBase : public QuicSocket, QuicStreamPrioritiesObserver {
       const std::pair<QuicErrorCode, folly::StringPiece>& cancelCode);
 
   class CallbackDispatcher : public folly::DelayedDestruction,
-                             public ConnectionCallback {
+                             public ConnectionSetupCallback,
+                             public ConnectionCallbackNew {
    public:
     using UniquePtr = std::unique_ptr<CallbackDispatcher, Destructor>;
 
@@ -940,10 +938,6 @@ class QuicTransportBase : public QuicSocket, QuicStreamPrioritiesObserver {
     }
 
     // Callback setters.
-    void setConnectionCallback(ConnectionCallback* callback) {
-      connSetupCallback_ = callback;
-      connStreamsCallback_ = callback;
-    }
     void setConnectionSetupCallback(ConnectionSetupCallback* callback) {
       connSetupCallback_ = callback;
     }
@@ -1028,11 +1022,6 @@ class QuicTransportBase : public QuicSocket, QuicStreamPrioritiesObserver {
 
   uint64_t qlogRefcnt_{0};
 
-  // Temp flag controlling which connection callbacks to use - old single
-  // callback object or two new split callback objects. Will be removed out once
-  // mvfst is switched to the new split callbacks eventually.
-  bool useSplitConnectionCallbacks_{false};
-
   // Priority level threshold for background streams
   // If all streams have equal or lower priority to the threshold
   // (value >= threshold), the connection is considered to be in backround mode.

quic/api/test/MockQuicSocket.h

@@ -112,7 +112,6 @@ class MockQuicSocket : public QuicSocket {
           StreamId,
           ReadCallback*,
           folly::Optional<ApplicationErrorCode> err));
-  MOCK_METHOD1(setConnectionCallback, void(ConnectionCallback*));
   MOCK_METHOD1(setConnectionSetupCallback, void(ConnectionSetupCallback*));
   MOCK_METHOD1(setConnectionCallbackNew, void(ConnectionCallbackNew*));
   void setEarlyDataAppParamsFunctions(

quic/api/test/QuicTransportBaseTest.cpp

@@ -553,9 +553,8 @@ TEST_F(QuicTransportImplTest, AckTimeoutExpiredWillResetTimeoutFlag) {
 }
 
 TEST_F(QuicTransportImplTest, IdleTimeoutExpiredDestroysTransport) {
-  EXPECT_CALL(connCallback, onConnectionEnd()).WillOnce(Invoke([&]() {
+  EXPECT_CALL(connSetupCallback, onConnectionSetupError(_))
-    transport = nullptr;
+      .WillOnce(Invoke([&](auto) { transport = nullptr; }));
-  }));
   transport->invokeIdleTimeout();
 }
 
@@ -1171,8 +1170,8 @@ TEST_F(QuicTransportImplTest, onNewBidirectionalStreamSetReadCallback) {
 
 TEST_F(QuicTransportImplTest, OnInvalidServerStream) {
   EXPECT_CALL(
-      connCallback,
+      connSetupCallback,
-      onConnectionError(IsError(TransportErrorCode::STREAM_STATE_ERROR)));
+      onConnectionSetupError(IsError(TransportErrorCode::STREAM_STATE_ERROR)));
   auto readData = folly::IOBuf::copyBuffer("actual stream data");
   StreamId stream1 = 29;
   transport->addDataToStream(stream1, StreamBuffer(readData->clone(), 0, true));
@@ -1412,8 +1411,8 @@ TEST_F(QuicTransportImplTest, ConnectionErrorUnhandledException) {
   transport->transportConn->oneRttWriteCipher = test::createNoOpAead();
   auto stream = transport->createBidirectionalStream().value();
   EXPECT_CALL(
-      connCallback,
+      connSetupCallback,
-      onConnectionError(std::make_pair(
+      onConnectionSetupError(std::make_pair(
           QuicErrorCode(TransportErrorCode::INTERNAL_ERROR),
           std::string("Well there's your problem"))));
   EXPECT_CALL(*socketPtr, write(_, _)).WillOnce(Invoke([](auto&, auto&) {
@@ -2844,9 +2843,8 @@ TEST_F(QuicTransportImplTest, ExceptionInWriteLooperDoesNotCrash) {
   transport->addDataToStream(
       stream, StreamBuffer(IOBuf::copyBuffer("hello"), 0, false));
   EXPECT_CALL(*socketPtr, write(_, _)).WillOnce(SetErrnoAndReturn(EBADF, -1));
-  EXPECT_CALL(connCallback, onConnectionError(_)).WillOnce(Invoke([&](auto) {
+  EXPECT_CALL(connSetupCallback, onConnectionSetupError(_))
-    transport.reset();
+      .WillOnce(Invoke([&](auto) { transport.reset(); }));
-  }));
   transport->writeLooper()->runLoopCallback();
 }
 

quic/client/QuicClientAsyncTransport.cpp

@@ -15,7 +15,7 @@ namespace quic {
 QuicClientAsyncTransport::QuicClientAsyncTransport(
     const std::shared_ptr<quic::QuicClientTransport>& clientSock) {
   setSocket(clientSock);
-  clientSock->start(this);
+  clientSock->start(this, this);
 }
 
 void QuicClientAsyncTransport::onNewBidirectionalStream(

quic/client/QuicClientAsyncTransport.h

@@ -17,7 +17,8 @@ namespace quic {
  * for experiments with QUIC in code using folly::AsyncSockets.
  */
 class QuicClientAsyncTransport : public QuicStreamAsyncTransport,
-                                 public QuicSocket::ConnectionCallback {
+                                 public QuicSocket::ConnectionSetupCallback,
+                                 public QuicSocket::ConnectionCallbackNew {
  public:
   using UniquePtr = std::unique_ptr<
       QuicClientAsyncTransport,

quic/client/QuicClientTransport.cpp

@@ -38,14 +38,12 @@ QuicClientTransport::QuicClientTransport(
     std::unique_ptr<folly::AsyncUDPSocket> socket,
     std::shared_ptr<ClientHandshakeFactory> handshakeFactory,
     size_t connectionIdSize,
-    PacketNum startingPacketNum,
+    PacketNum startingPacketNum)
-    bool useSplitConnectionCallbacks)
     : QuicClientTransport(
           evb,
           std::move(socket),
           std::move(handshakeFactory),
-          connectionIdSize,
+          connectionIdSize) {
-          useSplitConnectionCallbacks) {
   conn_->ackStates = AckStates(startingPacketNum);
 }
 
@@ -53,9 +51,8 @@ QuicClientTransport::QuicClientTransport(
     folly::EventBase* evb,
     std::unique_ptr<folly::AsyncUDPSocket> socket,
     std::shared_ptr<ClientHandshakeFactory> handshakeFactory,
-    size_t connectionIdSize,
+    size_t connectionIdSize)
-    bool useSplitConnectionCallbacks)
+    : QuicTransportBase(evb, std::move(socket)),
-    : QuicTransportBase(evb, std::move(socket), useSplitConnectionCallbacks),
       happyEyeballsConnAttemptDelayTimeout_(this) {
   DCHECK(handshakeFactory);
   auto tempConn =
@@ -1494,20 +1491,9 @@ void QuicClientTransport::
   runOnEvbAsync([&](auto) { markZeroRttPacketsLost(*conn_, markPacketLoss); });
 }
 
-void QuicClientTransport::start(ConnectionCallback* cb) {
-  startBase(cb, nullptr, nullptr);
-}
-
 void QuicClientTransport::start(
     ConnectionSetupCallback* connSetupCb,
     ConnectionCallbackNew* connCb) {
-  startBase(nullptr, connSetupCb, connCb);
-}
-
-void QuicClientTransport::startBase(
-    ConnectionCallback* cb,
-    ConnectionSetupCallback* connSetupCb,
-    ConnectionCallbackNew* connCb) {
   if (happyEyeballsEnabled_) {
     // TODO Supply v4 delay amount from somewhere when we want to tune this
     startHappyEyeballs(
@@ -1528,12 +1514,10 @@ void QuicClientTransport::startBase(
   if (conn_->qLogger) {
     conn_->qLogger->addTransportStateUpdate(kStart);
   }
-  if (cb) {
+
-    setConnectionCallback(cb);
+  setConnectionSetupCallback(connSetupCb);
-  } else {
+  setConnectionCallbackNew(connCb);
-    setConnectionSetupCallback(connSetupCb);
+
-    setConnectionCallbackNew(connCb);
-  }
   clientConn_->pendingOneRttData.reserve(
       conn_->transportSettings.maxPacketsToBuffer);
   try {

quic/client/QuicClientTransport.h

@@ -31,8 +31,7 @@ class QuicClientTransport
       folly::EventBase* evb,
       std::unique_ptr<folly::AsyncUDPSocket> socket,
       std::shared_ptr<ClientHandshakeFactory> handshakeFactory,
-      size_t connectionIdSize = 0,
+      size_t connectionIdSize = 0);
-      bool useSplitConnectionCallbacks = false);
 
   // Testing only API:
   QuicClientTransport(
@@ -40,8 +39,7 @@ class QuicClientTransport
       std::unique_ptr<folly::AsyncUDPSocket> socket,
       std::shared_ptr<ClientHandshakeFactory> handshakeFactory,
       size_t connectionIdSize,
-      PacketNum startingPacketNum,
+      PacketNum startingPacketNum);
-      bool useSplitConnectionCallbacks = false);
 
   ~QuicClientTransport() override;
 
@@ -60,14 +58,9 @@ class QuicClientTransport
       folly::EventBase* evb,
       std::unique_ptr<folly::AsyncUDPSocket> sock,
       std::shared_ptr<ClientHandshakeFactory> handshakeFactory,
-      size_t connectionIdSize = 0,
+      size_t connectionIdSize = 0) {
-      bool useSplitConnectionCallbacks = false) {
     auto client = std::make_shared<TransportType>(
-        evb,
+        evb, std::move(sock), std::move(handshakeFactory), connectionIdSize);
-        std::move(sock),
-        std::move(handshakeFactory),
-        connectionIdSize,
-        useSplitConnectionCallbacks);
     client->setSelfOwning();
     return client;
   }
@@ -95,11 +88,6 @@ class QuicClientTransport
   /**
    * Starts the connection.
    */
-  virtual void start(ConnectionCallback* cb);
-
-  /**
-   * Starts the connection with split callbacks.
-   */
   virtual void start(
       ConnectionSetupCallback* connSetupCb,
       ConnectionCallbackNew* connCb);
@@ -239,11 +227,6 @@ class QuicClientTransport
    */
   void maybeSendTransportKnobs();
 
-  void startBase(
-      ConnectionCallback* cb,
-      ConnectionSetupCallback* connSetupCb,
-      ConnectionCallbackNew* connStreamsCb);
-
   bool replaySafeNotified_{false};
   // Set it QuicClientTransport is in a self owning mode. This will be cleaned
   // up when the caller invokes a terminal call to the transport.

quic/client/connector/QuicConnector.cpp

@@ -64,8 +64,7 @@ void QuicConnector::connect(
           .setCertificateVerifier(std::move(verifier))
           .setPskCache(std::move(quicPskCache))
           .build(),
-      0, /* connectionIdSize */
+      0 /* connectionIdSize */);
-      true /* useSplitConnectionCallbacks */);
   quicClient_->setHostname(sni.value_or(connectAddr.getAddressStr()));
   quicClient_->addNewPeerAddress(connectAddr);
   if (localAddr.hasValue()) {

quic/fizz/client/test/QuicClientTransportTest.cpp

@@ -385,7 +385,7 @@ TEST_P(QuicClientTransportIntegrationTest, TLSAlert) {
 
   auto qLogger = std::make_shared<FileQLogger>(VantagePoint::Client);
   client->getNonConstConn().qLogger = qLogger;
-  EXPECT_CALL(clientConnCallback, onConnectionError(_))
+  EXPECT_CALL(clientConnSetupCallback, onConnectionSetupError(_))
       .WillOnce(Invoke([&](const auto& errorCode) {
         LOG(ERROR) << "error: " << errorCode.second;
         const TransportErrorCode* transportError =
@@ -411,7 +411,7 @@ TEST_P(QuicClientTransportIntegrationTest, BadServerTest) {
   auto tp = client->getTransportSettings();
   tp.maxNumPTOs = 4;
   client->setTransportSettings(tp);
-  EXPECT_CALL(clientConnCallback, onConnectionError(_))
+  EXPECT_CALL(clientConnSetupCallback, onConnectionSetupError(_))
       .WillOnce(Invoke([&](const auto& errorCode) {
         LOG(ERROR) << "error: " << errorCode.second;
         const LocalErrorCode* localError = errorCode.first.asLocalErrorCode();
@@ -991,7 +991,7 @@ TEST_F(QuicClientTransportTest, CloseSocketOnWriteError) {
   client->start(&clientConnSetupCallback, &clientConnCallback);
 
   EXPECT_FALSE(client->isClosed());
-  EXPECT_CALL(clientConnCallback, onConnectionError(_));
+  EXPECT_CALL(clientConnSetupCallback, onConnectionSetupError(_));
   eventbase_->loopOnce();
   EXPECT_TRUE(client->isClosed());
 }
@@ -1053,7 +1053,8 @@ TEST_F(QuicClientTransportTest, onNetworkSwitchReplaceNoHandshake) {
 
 TEST_F(QuicClientTransportTest, SocketClosedDuringOnTransportReady) {
   class ConnectionCallbackThatWritesOnTransportReady
-      : public QuicSocket::ConnectionCallback {
+      : public QuicSocket::ConnectionSetupCallback,
+        public QuicSocket::ConnectionCallbackNew {
    public:
     explicit ConnectionCallbackThatWritesOnTransportReady(
         std::shared_ptr<QuicSocket> socket)
@@ -1105,7 +1106,7 @@ TEST_F(QuicClientTransportTest, SocketClosedDuringOnTransportReady) {
 
   client->addNewPeerAddress(serverAddr);
   setupCryptoLayer();
-  client->start(&callback);
+  client->start(&callback, &callback);
   setConnectionIds();
   EXPECT_THROW(recvServerHello(), std::runtime_error);
 }
@@ -1113,7 +1114,7 @@ TEST_F(QuicClientTransportTest, SocketClosedDuringOnTransportReady) {
 TEST_F(QuicClientTransportTest, NetworkUnreachableIsFatalToConn) {
   client->addNewPeerAddress(serverAddr);
   setupCryptoLayer();
-  EXPECT_CALL(clientConnCallback, onConnectionError(_));
+  EXPECT_CALL(clientConnSetupCallback, onConnectionSetupError(_));
   EXPECT_CALL(*sock, write(_, _)).WillOnce(SetErrnoAndReturn(ENETUNREACH, -1));
   client->start(&clientConnSetupCallback, &clientConnCallback);
   loopForWrites();
@@ -1915,7 +1916,7 @@ class QuicClientTransportHappyEyeballsTest
         .WillOnce(SetErrnoAndReturn(EBADF, -1));
     EXPECT_CALL(*secondSock, write(secondAddress, _))
         .WillOnce(SetErrnoAndReturn(EBADF, -1));
-    EXPECT_CALL(clientConnCallback, onConnectionError(_));
+    EXPECT_CALL(clientConnSetupCallback, onConnectionSetupError(_));
     client->lossTimeout().cancelTimeout();
     client->lossTimeout().timeoutExpired();
 

quic/samples/echo/EchoClient.h

@@ -26,7 +26,8 @@
 
 namespace quic {
 namespace samples {
-class EchoClient : public quic::QuicSocket::ConnectionCallback,
+class EchoClient : public quic::QuicSocket::ConnectionSetupCallback,
+                   public quic::QuicSocket::ConnectionCallbackNew,
                    public quic::QuicSocket::ReadCallback,
                    public quic::QuicSocket::WriteCallback {
  public:
@@ -134,7 +135,7 @@ class EchoClient : public quic::QuicSocket::ConnectionCallback,
           std::make_shared<LogQuicStats>("client"));
 
       LOG(INFO) << "EchoClient connecting to " << addr.describe();
-      quicClient_->start(this);
+      quicClient_->start(this, this);
     });
 
     startDone_.wait();

quic/server/QuicServerTransport.cpp

@@ -20,22 +20,6 @@
 
 namespace quic {
 
-QuicServerTransport::QuicServerTransport(
-    folly::EventBase* evb,
-    std::unique_ptr<folly::AsyncUDPSocket> sock,
-    ConnectionCallback& cb,
-    std::shared_ptr<const fizz::server::FizzServerContext> ctx,
-    std::unique_ptr<CryptoFactory> cryptoFactory,
-    PacketNum startingPacketNum)
-    : QuicServerTransport(
-          evb,
-          std::move(sock),
-          cb,
-          std::move(ctx),
-          std::move(cryptoFactory)) {
-  conn_->ackStates = AckStates(startingPacketNum);
-}
-
 QuicServerTransport::QuicServerTransport(
     folly::EventBase* evb,
     std::unique_ptr<folly::AsyncUDPSocket> sock,
@@ -54,31 +38,6 @@ QuicServerTransport::QuicServerTransport(
   conn_->ackStates = AckStates(startingPacketNum);
 }
 
-QuicServerTransport::QuicServerTransport(
-    folly::EventBase* evb,
-    std::unique_ptr<folly::AsyncUDPSocket> sock,
-    ConnectionCallback& cb,
-    std::shared_ptr<const fizz::server::FizzServerContext> ctx,
-    std::unique_ptr<CryptoFactory> cryptoFactory)
-    : QuicTransportBase(
-          evb,
-          std::move(sock),
-          false /* useSplitConnectionCallbacks */),
-      ctx_(std::move(ctx)) {
-  auto tempConn = std::make_unique<QuicServerConnectionState>(
-      FizzServerQuicHandshakeContext::Builder()
-          .setFizzServerContext(ctx_)
-          .setCryptoFactory(std::move(cryptoFactory))
-          .build());
-  tempConn->serverAddr = socket_->address();
-  serverConn_ = tempConn.get();
-  conn_.reset(tempConn.release());
-  conn_->observers = observers_;
-
-  setConnectionCallback(&cb);
-  registerAllTransportKnobParamHandlers();
-}
-
 QuicServerTransport::QuicServerTransport(
     folly::EventBase* evb,
     std::unique_ptr<folly::AsyncUDPSocket> sock,
@@ -86,11 +45,7 @@ QuicServerTransport::QuicServerTransport(
     ConnectionCallbackNew* connStreamsCb,
     std::shared_ptr<const fizz::server::FizzServerContext> ctx,
     std::unique_ptr<CryptoFactory> cryptoFactory)
-    : QuicTransportBase(
+    : QuicTransportBase(evb, std::move(sock)), ctx_(std::move(ctx)) {
-          evb,
-          std::move(sock),
-          true /* useSplitConnectionCallbacks */),
-      ctx_(std::move(ctx)) {
   auto tempConn = std::make_unique<QuicServerConnectionState>(
       FizzServerQuicHandshakeContext::Builder()
           .setFizzServerContext(ctx_)
@@ -118,14 +73,6 @@ QuicServerTransport::~QuicServerTransport() {
       false);
 }
 
-QuicServerTransport::Ptr QuicServerTransport::make(
-    folly::EventBase* evb,
-    std::unique_ptr<folly::AsyncUDPSocket> sock,
-    ConnectionCallback& cb,
-    std::shared_ptr<const fizz::server::FizzServerContext> ctx) {
-  return std::make_shared<QuicServerTransport>(evb, std::move(sock), cb, ctx);
-}
-
 QuicServerTransport::Ptr QuicServerTransport::make(
     folly::EventBase* evb,
     std::unique_ptr<folly::AsyncUDPSocket> sock,

quic/server/QuicServerTransport.h

@@ -58,12 +58,6 @@ class QuicServerTransport
     virtual void onHandshakeUnfinished() noexcept = 0;
   };
 
-  static QuicServerTransport::Ptr make(
-      folly::EventBase* evb,
-      std::unique_ptr<folly::AsyncUDPSocket> sock,
-      ConnectionCallback& cb,
-      std::shared_ptr<const fizz::server::FizzServerContext> ctx);
-
   static QuicServerTransport::Ptr make(
       folly::EventBase* evb,
       std::unique_ptr<folly::AsyncUDPSocket> sock,
@@ -71,13 +65,6 @@ class QuicServerTransport
       ConnectionCallbackNew* connStreamsCb,
       std::shared_ptr<const fizz::server::FizzServerContext> ctx);
 
-  QuicServerTransport(
-      folly::EventBase* evb,
-      std::unique_ptr<folly::AsyncUDPSocket> sock,
-      ConnectionCallback& cb,
-      std::shared_ptr<const fizz::server::FizzServerContext> ctx,
-      std::unique_ptr<CryptoFactory> cryptoFactory = nullptr);
-
   QuicServerTransport(
       folly::EventBase* evb,
       std::unique_ptr<folly::AsyncUDPSocket> sock,
@@ -87,14 +74,6 @@ class QuicServerTransport
       std::unique_ptr<CryptoFactory> cryptoFactory = nullptr);
 
   // Testing only API:
-  QuicServerTransport(
-      folly::EventBase* evb,
-      std::unique_ptr<folly::AsyncUDPSocket> sock,
-      ConnectionCallback& cb,
-      std::shared_ptr<const fizz::server::FizzServerContext> ctx,
-      std::unique_ptr<CryptoFactory> cryptoFactory,
-      PacketNum startingPacketNum);
-
   QuicServerTransport(
       folly::EventBase* evb,
       std::unique_ptr<folly::AsyncUDPSocket> sock,

quic/server/async_tran/QuicAsyncTransportAcceptor.cpp

@@ -30,8 +30,8 @@ quic::QuicServerTransport::Ptr QuicAsyncTransportAcceptor::make(
   CHECK_EQ(evb, evb_);
   quic::QuicServerAsyncTransport::UniquePtr asyncWrapper(
       new quic::QuicServerAsyncTransport());
-  auto transport =
+  auto transport = quic::QuicServerTransport::make(
-      quic::QuicServerTransport::make(evb, std::move(sock), *asyncWrapper, ctx);
+      evb, std::move(sock), asyncWrapper.get(), asyncWrapper.get(), ctx);
   asyncWrapper->setServerSocket(transport);
   wangle::ManagedConnection* managedConnection =
       connectionFactory_(std::move(asyncWrapper));

quic/server/async_tran/QuicServerAsyncTransport.h

@@ -12,7 +12,8 @@
 namespace quic {
 
 class QuicServerAsyncTransport : public QuicStreamAsyncTransport,
-                                 public QuicSocket::ConnectionCallback {
+                                 public QuicSocket::ConnectionSetupCallback,
+                                 public QuicSocket::ConnectionCallbackNew {
  public:
   using UniquePtr = std::unique_ptr<
       QuicServerAsyncTransport,

quic/tools/tperf/tperf.cpp

@@ -229,7 +229,8 @@ class TPerfAcceptObserver : public AcceptObserver {
 
 } // namespace
 
-class ServerStreamHandler : public quic::QuicSocket::ConnectionCallback,
+class ServerStreamHandler : public quic::QuicSocket::ConnectionSetupCallback,
+                            public quic::QuicSocket::ConnectionCallbackNew,
                             public quic::QuicSocket::ReadCallback,
                             public quic::QuicSocket::WriteCallback {
  public:
@@ -444,7 +445,7 @@ class TPerfServerTransportFactory : public quic::QuicServerTransportFactory {
     auto serverHandler = std::make_unique<ServerStreamHandler>(
         evb, blockSize_, numStreams_, maxBytesPerStream_, *sock, dsrEnabled_);
     auto transport = quic::QuicServerTransport::make(
-        evb, std::move(sock), *serverHandler, ctx);
+        evb, std::move(sock), serverHandler.get(), serverHandler.get(), ctx);
     if (!FLAGS_server_qlogger_path.empty()) {
       auto qlogger = std::make_shared<TperfQLogger>(
           VantagePoint::Server, FLAGS_server_qlogger_path);
@@ -572,7 +573,8 @@ class TPerfServer {
   quic::QuicCcpThreadLauncher quicCcpThreadLauncher_;
 };
 
-class TPerfClient : public quic::QuicSocket::ConnectionCallback,
+class TPerfClient : public quic::QuicSocket::ConnectionSetupCallback,
+                    public quic::QuicSocket::ConnectionCallbackNew,
                     public quic::QuicSocket::ReadCallback,
                     public quic::QuicSocket::WriteCallback,
                     public folly::HHWheelTimer::Callback {
@@ -759,7 +761,7 @@ class TPerfClient : public quic::QuicSocket::ConnectionCallback,
     quicClient_->setTransportSettings(settings);
 
     LOG(INFO) << "TPerfClient connecting to " << addr.describe();
-    quicClient_->start(this);
+    quicClient_->start(this, this);
     eventBase_.loopForever();
   }