Rename ConnectionCallbackNew back to ConnectionCallback

Summary: Rename ConnectionCallbackNew back to ConnectionCallback

Reviewed By: mjoras

Differential Revision: D33979956

fbshipit-source-id: 6c133a406c4bf6799838ffc36701267a938cb4a3

quic/api/QuicSocket.h

@@ -69,9 +69,9 @@ class QuicSocket {
    * Callback for connection level events once connection is set up.
    * The name is temporary until we phase out the old monolithic callback.
    */
-  class ConnectionCallbackNew {
+  class ConnectionCallback {
    public:
-    virtual ~ConnectionCallbackNew() = default;
+    virtual ~ConnectionCallback() = default;
 
     /**
      * Invoked when stream id's flow control state changes.  This is an edge
@@ -223,7 +223,7 @@ class QuicSocket {
    * Sets connection streams callback. This callback must be set after
    * connection set up is finished and is ready for streams processing.
    */
-  virtual void setConnectionCallbackNew(ConnectionCallbackNew* callback) = 0;
+  virtual void setConnectionCallback(ConnectionCallback* callback) = 0;
 
   /**
    * Sets the functions that mvfst will invoke to validate early data params

quic/api/QuicTransportBase.cpp

@@ -2705,8 +2705,7 @@ void QuicTransportBase::setConnectionSetupCallback(
   connSetupCallback_ = callback;
 }
 
-void QuicTransportBase::setConnectionCallbackNew(
+void QuicTransportBase::setConnectionCallback(ConnectionCallback* callback) {
-    ConnectionCallbackNew* callback) {
   connCallback_ = callback;
 }
 

quic/api/QuicTransportBase.h

@@ -225,7 +225,7 @@ class QuicTransportBase : public QuicSocket, QuicStreamPrioritiesObserver {
 
   void setConnectionSetupCallback(ConnectionSetupCallback* callback) final;
 
-  void setConnectionCallbackNew(ConnectionCallbackNew* callback) final;
+  void setConnectionCallback(ConnectionCallback* callback) final;
 
   void setEarlyDataAppParamsFunctions(
       folly::Function<bool(const folly::Optional<std::string>&, const Buf&)
@@ -866,7 +866,7 @@ class QuicTransportBase : public QuicSocket, QuicStreamPrioritiesObserver {
   std::atomic<folly::EventBase*> evb_;
   std::unique_ptr<folly::AsyncUDPSocket> socket_;
   ConnectionSetupCallback* connSetupCallback_{nullptr};
-  ConnectionCallbackNew* connCallback_{nullptr};
+  ConnectionCallback* connCallback_{nullptr};
   // A flag telling transport if the new onConnectionEnd(error) cb must be used.
   bool useConnectionEndWithErrorCallback_{false};
 

quic/api/test/MockQuicSocket.h

@@ -20,7 +20,7 @@ class MockQuicSocket : public QuicSocket {
   MockQuicSocket(
       folly::EventBase* /*eventBase*/,
       ConnectionSetupCallback* setupCb,
-      ConnectionCallbackNew* connCb)
+      ConnectionCallback* connCb)
       : setupCb_(setupCb), connCb_(connCb) {}
 
   MOCK_CONST_METHOD0(good, bool());
@@ -109,7 +109,7 @@ class MockQuicSocket : public QuicSocket {
           ReadCallback*,
           folly::Optional<ApplicationErrorCode> err));
   MOCK_METHOD1(setConnectionSetupCallback, void(ConnectionSetupCallback*));
-  MOCK_METHOD1(setConnectionCallbackNew, void(ConnectionCallbackNew*));
+  MOCK_METHOD1(setConnectionCallback, void(ConnectionCallback*));
   void setEarlyDataAppParamsFunctions(
       folly::Function<bool(const folly::Optional<std::string>&, const Buf&)
                           const> validator,
@@ -292,7 +292,7 @@ class MockQuicSocket : public QuicSocket {
   MOCK_METHOD1(setCongestionControl, void(CongestionControlType));
 
   ConnectionSetupCallback* setupCb_;
-  ConnectionCallbackNew* connCb_;
+  ConnectionCallback* connCb_;
 
   folly::Function<bool(const folly::Optional<std::string>&, const Buf&)>
       earlyDataAppParamsValidator_;

quic/api/test/Mocks.h

@@ -120,9 +120,9 @@ class MockConnectionSetupCallback : public QuicSocket::ConnectionSetupCallback {
 #endif
 };
 
-class MockConnectionCallbackNew : public QuicSocket::ConnectionCallbackNew {
+class MockConnectionCallback : public QuicSocket::ConnectionCallback {
  public:
-  ~MockConnectionCallbackNew() override = default;
+  ~MockConnectionCallback() override = default;
 
 #if defined(MOCK_METHOD)
   MOCK_METHOD((void), onFlowControlUpdate, (StreamId), (noexcept));
@@ -240,7 +240,7 @@ class MockQuicTransport : public QuicServerTransport {
       folly::EventBase* evb,
       std::unique_ptr<folly::AsyncUDPSocket> sock,
       ConnectionSetupCallback* connSetupCb,
-      ConnectionCallbackNew* connCb,
+      ConnectionCallback* connCb,
       std::shared_ptr<const fizz::server::FizzServerContext> ctx)
       : QuicServerTransport(evb, std::move(sock), connSetupCb, connCb, ctx) {}
 

quic/api/test/QuicStreamAsyncTransportTest.cpp

@@ -158,7 +158,7 @@ class QuicStreamAsyncTransportTest : public Test {
   std::shared_ptr<QuicServer> server_;
   folly::SocketAddress serverAddr_;
   NiceMock<MockConnectionSetupCallback> serverConnectionSetupCB_;
-  NiceMock<MockConnectionCallbackNew> serverConnectionCB_;
+  NiceMock<MockConnectionCallback> serverConnectionCB_;
   std::shared_ptr<quic::QuicSocket> serverSocket_;
   QuicStreamAsyncTransport::UniquePtr serverAsyncWrapper_;
   folly::test::MockWriteCallback serverWriteCB_;
@@ -169,7 +169,7 @@ class QuicStreamAsyncTransportTest : public Test {
   folly::EventBase clientEvb_;
   std::thread clientEvbThread_;
   NiceMock<MockConnectionSetupCallback> clientConnectionSetupCB_;
-  NiceMock<MockConnectionCallbackNew> clientConnectionCB_;
+  NiceMock<MockConnectionCallback> clientConnectionCB_;
   QuicStreamAsyncTransport::UniquePtr clientAsyncWrapper_;
   folly::Promise<folly::Unit> startPromise_;
   folly::test::MockWriteCallback clientWriteCB_;

quic/api/test/QuicTransportBaseTest.cpp

@@ -199,10 +199,10 @@ class TestQuicTransport
       folly::EventBase* evb,
       std::unique_ptr<folly::AsyncUDPSocket> socket,
       ConnectionSetupCallback* connSetupCb,
-      ConnectionCallbackNew* connCb)
+      ConnectionCallback* connCb)
       : QuicTransportBase(evb, std::move(socket)) {
     setConnectionSetupCallback(connSetupCb);
-    setConnectionCallbackNew(connCb);
+    setConnectionCallback(connCb);
     auto conn = std::make_unique<QuicServerConnectionState>(
         FizzServerQuicHandshakeContext::Builder().build());
     conn->clientConnectionId = ConnectionId({10, 9, 8, 7});
@@ -533,7 +533,7 @@ class QuicTransportImplTest : public Test {
  protected:
   std::unique_ptr<folly::EventBase> evb;
   NiceMock<MockConnectionSetupCallback> connSetupCallback;
-  NiceMock<MockConnectionCallbackNew> connCallback;
+  NiceMock<MockConnectionCallback> connCallback;
   TestByteEventCallback byteEventCallback;
   std::shared_ptr<TestQuicTransport> transport;
   folly::test::MockAsyncUDPSocket* socketPtr;

quic/api/test/QuicTransportTest.cpp

@@ -115,7 +115,7 @@ class QuicTransportTest : public Test {
   folly::EventBase evb_;
   MockAsyncUDPSocket* socket_;
   NiceMock<MockConnectionSetupCallback> connSetupCallback_;
-  NiceMock<MockConnectionCallbackNew> connCallback_;
+  NiceMock<MockConnectionCallback> connCallback_;
   NiceMock<MockWriteCallback> writeCallback_;
   MockAead* aead_;
   std::unique_ptr<PacketNumberCipher> headerCipher_;

quic/api/test/TestQuicTransport.h

@@ -22,10 +22,10 @@ class TestQuicTransport
       folly::EventBase* evb,
       std::unique_ptr<folly::AsyncUDPSocket> socket,
       ConnectionSetupCallback* connSetupCb,
-      ConnectionCallbackNew* connCb)
+      ConnectionCallback* connCb)
       : QuicTransportBase(evb, std::move(socket)) {
     setConnectionSetupCallback(connSetupCb);
-    setConnectionCallbackNew(connCb);
+    setConnectionCallback(connCb);
     conn_.reset(new QuicServerConnectionState(
         FizzServerQuicHandshakeContext::Builder().build()));
     conn_->clientConnectionId = ConnectionId({9, 8, 7, 6});

quic/client/QuicClientAsyncTransport.h

@@ -18,7 +18,7 @@ namespace quic {
  */
 class QuicClientAsyncTransport : public QuicStreamAsyncTransport,
                                  public QuicSocket::ConnectionSetupCallback,
-                                 public QuicSocket::ConnectionCallbackNew {
+                                 public QuicSocket::ConnectionCallback {
  public:
   using UniquePtr = std::unique_ptr<
       QuicClientAsyncTransport,

quic/client/QuicClientTransport.cpp

@@ -1522,7 +1522,7 @@ void QuicClientTransport::
 
 void QuicClientTransport::start(
     ConnectionSetupCallback* connSetupCb,
-    ConnectionCallbackNew* connCb) {
+    ConnectionCallback* connCb) {
   if (happyEyeballsEnabled_) {
     // TODO Supply v4 delay amount from somewhere when we want to tune this
     startHappyEyeballs(
@@ -1545,7 +1545,7 @@ void QuicClientTransport::start(
   }
 
   setConnectionSetupCallback(connSetupCb);
-  setConnectionCallbackNew(connCb);
+  setConnectionCallback(connCb);
 
   clientConn_->pendingOneRttData.reserve(
       conn_->transportSettings.maxPacketsToBuffer);

quic/client/QuicClientTransport.h

@@ -97,7 +97,7 @@ class QuicClientTransport
    */
   virtual void start(
       ConnectionSetupCallback* connSetupCb,
-      ConnectionCallbackNew* connCb);
+      ConnectionCallback* connCb);
 
   /**
    * Returns whether or not TLS is resumed.

quic/client/test/Mocks.h

@@ -95,7 +95,7 @@ class MockQuicClientTransport : public quic::QuicClientTransport {
             std::move(handshakeFactory)),
         testType_(testType) {}
 
-  void start(ConnectionSetupCallback* connSetupCb, ConnectionCallbackNew*)
+  void start(ConnectionSetupCallback* connSetupCb, ConnectionCallback*)
       override {
     auto cancelCode = QuicError(
         QuicErrorCode(LocalErrorCode::NO_ERROR),

quic/fizz/client/test/QuicClientTransportTest.cpp

@@ -244,7 +244,7 @@ class QuicClientTransportIntegrationTest : public TestWithParam<TestingParams> {
   folly::EventBase eventbase_;
   folly::SocketAddress serverAddr;
   NiceMock<MockConnectionSetupCallback> clientConnSetupCallback;
-  NiceMock<MockConnectionCallbackNew> clientConnCallback;
+  NiceMock<MockConnectionCallback> clientConnCallback;
   NiceMock<MockReadCallback> readCb;
   std::shared_ptr<TestingQuicClientTransport> client;
   std::shared_ptr<fizz::server::FizzServerContext> serverCtx;
@@ -1052,7 +1052,7 @@ TEST_F(QuicClientTransportTest, onNetworkSwitchReplaceNoHandshake) {
 TEST_F(QuicClientTransportTest, SocketClosedDuringOnTransportReady) {
   class ConnectionCallbackThatWritesOnTransportReady
       : public QuicSocket::ConnectionSetupCallback,
-        public QuicSocket::ConnectionCallbackNew {
+        public QuicSocket::ConnectionCallback {
    public:
     explicit ConnectionCallbackThatWritesOnTransportReady(
         std::shared_ptr<QuicSocket> socket)

quic/fizz/client/test/QuicClientTransportTestUtil.h

@@ -540,7 +540,7 @@ class QuicClientTransportTestBase : public virtual testing::Test {
     return clientConnSetupCallback;
   }
 
-  MockConnectionCallbackNew& getConnCallback() {
+  MockConnectionCallback& getConnCallback() {
     return clientConnCallback;
   }
 
@@ -882,7 +882,7 @@ class QuicClientTransportTestBase : public virtual testing::Test {
   testing::NiceMock<MockDeliveryCallback> deliveryCallback;
   testing::NiceMock<MockReadCallback> readCb;
   testing::NiceMock<MockConnectionSetupCallback> clientConnSetupCallback;
-  testing::NiceMock<MockConnectionCallbackNew> clientConnCallback;
+  testing::NiceMock<MockConnectionCallback> clientConnCallback;
   folly::test::MockAsyncUDPSocket* sock;
   std::shared_ptr<TestingQuicClientTransport::DestructionCallback>
       destructionCallback;

quic/samples/echo/EchoClient.h

@@ -27,7 +27,7 @@
 namespace quic {
 namespace samples {
 class EchoClient : public quic::QuicSocket::ConnectionSetupCallback,
-                   public quic::QuicSocket::ConnectionCallbackNew,
+                   public quic::QuicSocket::ConnectionCallback,
                    public quic::QuicSocket::ReadCallback,
                    public quic::QuicSocket::WriteCallback {
  public:

quic/samples/echo/EchoHandler.h

@@ -15,7 +15,7 @@
 namespace quic {
 namespace samples {
 class EchoHandler : public quic::QuicSocket::ConnectionSetupCallback,
-                    public quic::QuicSocket::ConnectionCallbackNew,
+                    public quic::QuicSocket::ConnectionCallback,
                     public quic::QuicSocket::ReadCallback,
                     public quic::QuicSocket::WriteCallback {
  public:

quic/server/QuicServerTransport.cpp

@@ -24,7 +24,7 @@ QuicServerTransport::QuicServerTransport(
     folly::EventBase* evb,
     std::unique_ptr<folly::AsyncUDPSocket> sock,
     ConnectionSetupCallback* connSetupCb,
-    ConnectionCallbackNew* connStreamsCb,
+    ConnectionCallback* connStreamsCb,
     std::shared_ptr<const fizz::server::FizzServerContext> ctx,
     std::unique_ptr<CryptoFactory> cryptoFactory,
     PacketNum startingPacketNum)
@@ -42,7 +42,7 @@ QuicServerTransport::QuicServerTransport(
     folly::EventBase* evb,
     std::unique_ptr<folly::AsyncUDPSocket> sock,
     ConnectionSetupCallback* connSetupCb,
-    ConnectionCallbackNew* connStreamsCb,
+    ConnectionCallback* connStreamsCb,
     std::shared_ptr<const fizz::server::FizzServerContext> ctx,
     std::unique_ptr<CryptoFactory> cryptoFactory,
     bool useConnectionEndWithErrorCallback)
@@ -62,7 +62,7 @@ QuicServerTransport::QuicServerTransport(
   conn_->observers = observers_;
 
   setConnectionSetupCallback(connSetupCb);
-  setConnectionCallbackNew(connStreamsCb);
+  setConnectionCallback(connStreamsCb);
   registerAllTransportKnobParamHandlers();
 }
 
@@ -82,7 +82,7 @@ QuicServerTransport::Ptr QuicServerTransport::make(
     folly::EventBase* evb,
     std::unique_ptr<folly::AsyncUDPSocket> sock,
     ConnectionSetupCallback* connSetupCb,
-    ConnectionCallbackNew* connStreamsCb,
+    ConnectionCallback* connStreamsCb,
     std::shared_ptr<const fizz::server::FizzServerContext> ctx,
     bool useConnectionEndWithErrorCallback) {
   return std::make_shared<QuicServerTransport>(

quic/server/QuicServerTransport.h

@@ -62,7 +62,7 @@ class QuicServerTransport
       folly::EventBase* evb,
       std::unique_ptr<folly::AsyncUDPSocket> sock,
       ConnectionSetupCallback* connSetupCb,
-      ConnectionCallbackNew* connStreamsCb,
+      ConnectionCallback* connStreamsCb,
       std::shared_ptr<const fizz::server::FizzServerContext> ctx,
       bool useConnectionEndWithErrorCallback = false);
 
@@ -70,7 +70,7 @@ class QuicServerTransport
       folly::EventBase* evb,
       std::unique_ptr<folly::AsyncUDPSocket> sock,
       ConnectionSetupCallback* connSetupCb,
-      ConnectionCallbackNew* connStreamsCb,
+      ConnectionCallback* connStreamsCb,
       std::shared_ptr<const fizz::server::FizzServerContext> ctx,
       std::unique_ptr<CryptoFactory> cryptoFactory = nullptr,
       bool useConnectionEndWithErrorCallback = false);
@@ -80,7 +80,7 @@ class QuicServerTransport
       folly::EventBase* evb,
       std::unique_ptr<folly::AsyncUDPSocket> sock,
       ConnectionSetupCallback* connSetupCb,
-      ConnectionCallbackNew* connStreamsCb,
+      ConnectionCallback* connStreamsCb,
       std::shared_ptr<const fizz::server::FizzServerContext> ctx,
       std::unique_ptr<CryptoFactory> cryptoFactory,
       PacketNum startingPacketNum);

quic/server/async_tran/QuicServerAsyncTransport.h

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

quic/server/handshake/test/DefaultAppTokenValidatorTest.cpp

@@ -314,7 +314,7 @@ TEST(DefaultAppTokenValidatorTest, TestInvalidAppParams) {
   conn.statsCallback = quicStats.get();
 
   MockConnectionSetupCallback connSetupCallback;
-  MockConnectionCallbackNew connCallback;
+  MockConnectionCallback connCallback;
 
   AppToken appToken;
   appToken.transportParams = createTicketTransportParameters(

quic/server/test/QuicServerTest.cpp

@@ -72,7 +72,7 @@ TEST_F(SimpleQuicServerWorkerTest, RejectCid) {
       std::make_unique<folly::test::MockAsyncUDPSocket>(&eventbase_);
   EXPECT_CALL(*mockSock, address()).WillRepeatedly(ReturnRef(addr));
   MockConnectionSetupCallback mockConnectionSetupCallback;
-  MockConnectionCallbackNew mockConnectionCallback;
+  MockConnectionCallback mockConnectionCallback;
   MockQuicTransport::Ptr transportPtr = std::make_shared<MockQuicTransport>(
       &eventbase_,
       std::move(mockSock),
@@ -170,7 +170,7 @@ class QuicServerWorkerTest : public Test {
     EXPECT_CALL(*socketFactory_, _make(_, _)).WillRepeatedly(Return(nullptr));
     worker_->setNewConnectionSocketFactory(socketFactory_.get());
     NiceMock<MockConnectionSetupCallback> connSetupCb;
-    NiceMock<MockConnectionCallbackNew> connCb;
+    NiceMock<MockConnectionCallback> connCb;
     std::unique_ptr<folly::test::MockAsyncUDPSocket> mockSock =
         std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(
             &eventbase_);
@@ -547,7 +547,7 @@ TEST_F(QuicServerWorkerTest, RateLimit) {
   EXPECT_CALL(*quicStats_, onConnectionRateLimited()).Times(1);
 
   NiceMock<MockConnectionSetupCallback> connSetupCb1;
-  NiceMock<MockConnectionCallbackNew> connCb1;
+  NiceMock<MockConnectionCallback> connCb1;
   auto mockSock1 =
       std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_);
   EXPECT_CALL(*mockSock1, address()).WillRepeatedly(ReturnRef(fakeAddress_));
@@ -584,7 +584,7 @@ TEST_F(QuicServerWorkerTest, RateLimit) {
 
   auto caddr2 = folly::SocketAddress("2.3.4.5", 1234);
   NiceMock<MockConnectionSetupCallback> connSetupCb2;
-  NiceMock<MockConnectionCallbackNew> connCb2;
+  NiceMock<MockConnectionCallback> connCb2;
   auto mockSock2 =
       std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_);
   EXPECT_CALL(*mockSock2, address()).WillRepeatedly(ReturnRef(caddr2));
@@ -643,7 +643,7 @@ TEST_F(QuicServerWorkerTest, UnfinishedHandshakeLimit) {
   EXPECT_CALL(*quicStats_, onConnectionRateLimited()).Times(1);
 
   NiceMock<MockConnectionSetupCallback> connSetupCb1;
-  NiceMock<MockConnectionCallbackNew> connCb1;
+  NiceMock<MockConnectionCallback> connCb1;
   auto mockSock1 =
       std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_);
   EXPECT_CALL(*mockSock1, address()).WillRepeatedly(ReturnRef(fakeAddress_));
@@ -679,7 +679,7 @@ TEST_F(QuicServerWorkerTest, UnfinishedHandshakeLimit) {
 
   auto caddr2 = folly::SocketAddress("2.3.4.5", 1234);
   NiceMock<MockConnectionSetupCallback> connSetupCb2;
-  NiceMock<MockConnectionCallbackNew> connCb2;
+  NiceMock<MockConnectionCallback> connCb2;
   auto mockSock2 =
       std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_);
   EXPECT_CALL(*mockSock2, address()).WillRepeatedly(ReturnRef(caddr2));
@@ -734,7 +734,7 @@ TEST_F(QuicServerWorkerTest, UnfinishedHandshakeLimit) {
   worker_->onHandshakeFinished();
   auto caddr4 = folly::SocketAddress("4.3.4.5", 1234);
   NiceMock<MockConnectionSetupCallback> connSetupCb4;
-  NiceMock<MockConnectionCallbackNew> connCb4;
+  NiceMock<MockConnectionCallback> connCb4;
   auto mockSock4 =
       std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_);
   EXPECT_CALL(*mockSock4, address()).WillRepeatedly(ReturnRef(caddr4));
@@ -860,7 +860,7 @@ TEST_F(QuicServerWorkerTest, TestRetryInvalidInitialDstConnId) {
 
 TEST_F(QuicServerWorkerTest, QuicServerWorkerUnbindBeforeCidAvailable) {
   NiceMock<MockConnectionSetupCallback> connSetupCb;
-  NiceMock<MockConnectionCallbackNew> connCb;
+  NiceMock<MockConnectionCallback> connCb;
   auto mockSock =
       std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_);
   EXPECT_CALL(*mockSock, address()).WillRepeatedly(ReturnRef(fakeAddress_));
@@ -1041,7 +1041,7 @@ TEST_F(QuicServerWorkerTest, QuicServerNewConnection) {
   ConnectionId connId2({2, 4, 5, 6});
   folly::SocketAddress clientAddr2("2.3.4.5", 2345);
   NiceMock<MockConnectionSetupCallback> connSetupCb;
-  NiceMock<MockConnectionCallbackNew> connCb;
+  NiceMock<MockConnectionCallback> connCb;
   auto mockSock =
       std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_);
 
@@ -1430,7 +1430,7 @@ TEST_F(QuicServerWorkerTest, AcceptObserver) {
 
   auto initTestSocketAndTransport = [this]() {
     NiceMock<MockConnectionSetupCallback> connSetupCb;
-    NiceMock<MockConnectionCallbackNew> connCb;
+    NiceMock<MockConnectionCallback> connCb;
     auto mockSock = std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(
         &eventbase_);
     EXPECT_CALL(*mockSock, address()).WillRepeatedly(ReturnRef(fakeAddress_));
@@ -2092,7 +2092,7 @@ class QuicServerTest : public Test {
     std::shared_ptr<MockQuicTransport> transport;
     eventBase->runInEventBaseThreadAndWait([&] {
       NiceMock<MockConnectionSetupCallback> connSetupcb;
-      NiceMock<MockConnectionCallbackNew> connCb;
+      NiceMock<MockConnectionCallback> connCb;
       std::unique_ptr<folly::test::MockAsyncUDPSocket> mockSock =
           std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(
               eventBase);
@@ -2371,7 +2371,7 @@ class QuicServerTakeoverTest : public Test {
       folly::Baton<>& baton) {
     std::shared_ptr<MockQuicTransport> transport;
     NiceMock<MockConnectionSetupCallback> connSetupCb;
-    NiceMock<MockConnectionCallbackNew> connCb;
+    NiceMock<MockConnectionCallback> connCb;
     auto makeTransport =
         [&](folly::EventBase* eventBase,
             std::unique_ptr<folly::AsyncUDPSocket>& socket,
@@ -2939,7 +2939,7 @@ TEST_F(QuicServerTest, ZeroRttPacketRoute) {
   setUpTransportFactoryForWorkers(evbs);
   std::shared_ptr<MockQuicTransport> transport;
   NiceMock<MockConnectionSetupCallback> connSetupCb;
-  NiceMock<MockConnectionCallbackNew> connCb;
+  NiceMock<MockConnectionCallback> connCb;
   folly::Baton<> b;
   // create payload
   StreamId id = 1;
@@ -3034,7 +3034,7 @@ TEST_F(QuicServerTest, ZeroRttBeforeInitial) {
   setUpTransportFactoryForWorkers(evbs);
   std::shared_ptr<MockQuicTransport> transport;
   NiceMock<MockConnectionSetupCallback> connSetupCb;
-  NiceMock<MockConnectionCallbackNew> connCb;
+  NiceMock<MockConnectionCallback> connCb;
   folly::Baton<> b;
   // create payload
   StreamId id = 1;

quic/server/test/QuicServerTransportTestUtil.h

@@ -32,7 +32,7 @@ class TestingQuicServerTransport : public QuicServerTransport {
       folly::EventBase* evb,
       std::unique_ptr<folly::AsyncUDPSocket> sock,
       ConnectionSetupCallback* connSetupCb,
-      ConnectionCallbackNew* connCb,
+      ConnectionCallback* connCb,
       std::shared_ptr<const fizz::server::FizzServerContext> ctx)
       : QuicServerTransport(
             evb,
@@ -202,7 +202,7 @@ class QuicServerTransportTestBase : public virtual testing::Test {
     return connSetupCallback;
   }
 
-  MockConnectionCallbackNew& getConnCallback() {
+  MockConnectionCallback& getConnCallback() {
     return connCallback;
   }
 
@@ -559,7 +559,7 @@ class QuicServerTransportTestBase : public virtual testing::Test {
   folly::SocketAddress serverAddr;
   folly::SocketAddress clientAddr;
   testing::NiceMock<MockConnectionSetupCallback> connSetupCallback;
-  testing::NiceMock<MockConnectionCallbackNew> connCallback;
+  testing::NiceMock<MockConnectionCallback> connCallback;
   testing::NiceMock<MockRoutingCallback> routingCallback;
   testing::NiceMock<MockHandshakeFinishedCallback> handshakeFinishedCallback;
   folly::Optional<ConnectionId> clientConnectionId;

quic/tools/tperf/tperf.cpp

@@ -231,7 +231,7 @@ class TPerfAcceptObserver : public AcceptObserver {
 } // namespace
 
 class ServerStreamHandler : public quic::QuicSocket::ConnectionSetupCallback,
-                            public quic::QuicSocket::ConnectionCallbackNew,
+                            public quic::QuicSocket::ConnectionCallback,
                             public quic::QuicSocket::ReadCallback,
                             public quic::QuicSocket::WriteCallback {
  public:
@@ -568,7 +568,7 @@ class TPerfServer {
 };
 
 class TPerfClient : public quic::QuicSocket::ConnectionSetupCallback,
-                    public quic::QuicSocket::ConnectionCallbackNew,
+                    public quic::QuicSocket::ConnectionCallback,
                     public quic::QuicSocket::ReadCallback,
                     public quic::QuicSocket::WriteCallback,
                     public folly::HHWheelTimer::Callback {