Use folly::ObserverContainer for socket observer [2/x]

Summary:
This diff is part of larger change to switch to using `folly::ObserverContainer` (introduced in D27062840).

This diff:
- Renames `quic::Observer` to `quic::LegacyObserver`.
- Switches to using `quic::SocketObserverInterface` instead of `quic::Observer` when referencing structures used for the observer interface. For instance, `quic::Observer::WriteEvent` changes to `quic::SocketObserverInterface::WriteEvent`.

Differential Revision: D35000152

fbshipit-source-id: f387231fd58e8e763c3d7ed0a9c6fcec3b2324e2

quic/api/Observer.h

@@ -29,7 +29,7 @@ class QuicSocket;
 /**
  * Observer of socket events.
  */
-class Observer : public SocketObserverInterface {
+class LegacyObserver : public SocketObserverInterface {
  public:
   /**
    * Observer configuration.
@@ -78,17 +78,17 @@ class Observer : public SocketObserverInterface {
   /**
    * Constructor for observer, uses default config (all callbacks disabled).
    */
-  Observer() : Observer(Config()) {}
+  LegacyObserver() : LegacyObserver(Config()) {}
 
   /**
    * Constructor for observer.
    *
    * @param config      Config, defaults to auxilary instrumentaton disabled.
    */
-  explicit Observer(const Config& observerConfig)
+  explicit LegacyObserver(const Config& observerConfig)
       : observerConfig_(observerConfig) {}
 
-  ~Observer() override = default;
+  ~LegacyObserver() override = default;
 
   /**
    * Returns observers configuration.
@@ -130,6 +130,6 @@ class Observer : public SocketObserverInterface {
 
 // Container for instrumentation observers.
 // Avoids heap allocation for up to 2 observers being installed.
-using ObserverVec = SmallVec<Observer*, 2>;
+using ObserverVec = SmallVec<LegacyObserver*, 2>;
 
 } // namespace quic

quic/api/QuicSocket.h

@@ -1191,7 +1191,7 @@ class QuicSocket {
    *
    * @param observer     Observer to add (implements Observer).
    */
-  virtual void addObserver(Observer* observer) = 0;
+  virtual void addObserver(LegacyObserver* observer) = 0;
 
   /**
    * Removes an observer.
@@ -1199,7 +1199,7 @@ class QuicSocket {
    * @param observer     Observer to remove.
    * @return             Whether observer found and removed from list.
    */
-  virtual bool removeObserver(Observer* observer) = 0;
+  virtual bool removeObserver(LegacyObserver* observer) = 0;
 
   /**
    * Returns installed observers.

quic/api/QuicTransportBase.cpp

@@ -1487,7 +1487,9 @@ void QuicTransportBase::handleKnobCallbacks() {
       for (const auto& cb : *observers_) {
         if (cb->getConfig().knobFrameEvents) {
           cb->knobFrameReceived(
-              this, quic::Observer::KnobFrameEvent(Clock::now(), knobFrame));
+              this,
+              quic::SocketObserverInterface::KnobFrameEvent(
+                  Clock::now(), knobFrame));
         }
       }
 
@@ -1507,9 +1509,10 @@ void QuicTransportBase::handleAckEventCallbacks() {
     return; // nothing to do
   }
 
-  const auto event = quic::Observer::AcksProcessedEvent::Builder()
-                         .setAckEvents(lastProcessedAckEvents)
-                         .build();
+  const auto event =
+      quic::SocketObserverInterface::AcksProcessedEvent::Builder()
+          .setAckEvents(lastProcessedAckEvents)
+          .build();
   for (const auto& cb : *observers_) {
     if (cb->getConfig().acksProcessedEvents) {
       cb->acksProcessed(this, event);
@@ -1541,7 +1544,7 @@ void QuicTransportBase::handleNewStreamCallbacks(
     } else {
       connCallback_->onNewUnidirectionalStream(streamId);
     }
-    const Observer::StreamOpenEvent streamEvent(
+    const SocketObserverInterface::StreamOpenEvent streamEvent(
         streamId,
         getStreamInitiator(streamId),
         getStreamDirectionality(streamId));
@@ -1883,7 +1886,7 @@ QuicTransportBase::createStreamInternal(bool bidirectional) {
   }
   if (streamResult) {
     const StreamId streamId = streamResult.value()->id;
-    const Observer::StreamOpenEvent streamEvent(
+    const SocketObserverInterface::StreamOpenEvent streamEvent(
         streamId,
         getStreamInitiator(streamId),
         getStreamDirectionality(streamId));
@@ -2391,7 +2394,7 @@ void QuicTransportBase::checkForClosedStream() {
   auto itr = conn_->streamManager->closedStreams().begin();
   while (itr != conn_->streamManager->closedStreams().end()) {
     const auto& streamId = *itr;
-    const Observer::StreamCloseEvent streamEvent(
+    const SocketObserverInterface::StreamCloseEvent streamEvent(
         streamId,
         getStreamInitiator(streamId),
         getStreamDirectionality(streamId));
@@ -2826,7 +2829,7 @@ void QuicTransportBase::resetNonControlStreams(
   }
 }
 
-void QuicTransportBase::addObserver(Observer* observer) {
+void QuicTransportBase::addObserver(LegacyObserver* observer) {
   // adding the same observer multiple times is not allowed
   CHECK(
       std::find(observers_->begin(), observers_->end(), observer) ==
@@ -2836,7 +2839,7 @@ void QuicTransportBase::addObserver(Observer* observer) {
   observer->observerAttach(this);
 }
 
-bool QuicTransportBase::removeObserver(Observer* observer) {
+bool QuicTransportBase::removeObserver(LegacyObserver* observer) {
   auto it = std::find(observers_->begin(), observers_->end(), observer);
   if (it == observers_->end()) {
     return false;
@@ -3546,7 +3549,7 @@ QuicSocket::WriteResult QuicTransportBase::setDSRPacketizationRequestSender(
 
 void QuicTransportBase::notifyStartWritingFromAppRateLimited() {
   const auto event =
-      Observer::AppLimitedEvent::Builder()
+      SocketObserverInterface::AppLimitedEvent::Builder()
           .setOutstandingPackets(conn_->outstandings.packets)
           .setWriteCount(conn_->writeCount)
           .setLastPacketSentTime(conn_->lossState.maybeLastPacketSentTime)
@@ -3573,7 +3576,7 @@ void QuicTransportBase::notifyPacketsWritten(
     uint64_t numAckElicitingPacketsWritten,
     uint64_t numBytesWritten) {
   const auto event =
-      Observer::PacketsWrittenEvent::Builder()
+      SocketObserverInterface::PacketsWrittenEvent::Builder()
           .setOutstandingPackets(conn_->outstandings.packets)
           .setWriteCount(conn_->writeCount)
           .setLastPacketSentTime(conn_->lossState.maybeLastPacketSentTime)
@@ -3600,7 +3603,7 @@ void QuicTransportBase::notifyPacketsWritten(
 
 void QuicTransportBase::notifyAppRateLimited() {
   const auto event =
-      Observer::AppLimitedEvent::Builder()
+      SocketObserverInterface::AppLimitedEvent::Builder()
           .setOutstandingPackets(conn_->outstandings.packets)
           .setWriteCount(conn_->writeCount)
           .setLastPacketSentTime(conn_->lossState.maybeLastPacketSentTime)

quic/api/QuicTransportBase.h

@@ -652,7 +652,7 @@ class QuicTransportBase : public QuicSocket, QuicStreamPrioritiesObserver {
    *
    * @param observer     Observer to add (implements Observer).
    */
-  void addObserver(Observer* observer) override;
+  void addObserver(LegacyObserver* observer) override;
 
   /**
    * Removes an observer.
@@ -660,7 +660,7 @@ class QuicTransportBase : public QuicSocket, QuicStreamPrioritiesObserver {
    * @param observer     Observer to remove.
    * @return             Whether observer found and removed from list.
    */
-  bool removeObserver(Observer* observer) override;
+  bool removeObserver(LegacyObserver* observer) override;
 
   /**
    * Returns installed observers.

quic/api/test/MockQuicSocket.h

@@ -308,8 +308,8 @@ class MockQuicSocket : public QuicSocket {
       earlyDataAppParamsValidator_;
   folly::Function<Buf()> earlyDataAppParamsGetter_;
 
-  MOCK_METHOD(void, addObserver, (Observer*));
-  MOCK_METHOD(bool, removeObserver, (Observer*));
+  MOCK_METHOD(void, addObserver, (LegacyObserver*));
+  MOCK_METHOD(bool, removeObserver, (LegacyObserver*));
   MOCK_METHOD(const ObserverVec&, getObservers, (), (const));
   MOCK_METHOD(
       void,

quic/api/test/Mocks.h

@@ -258,11 +258,11 @@ class MockLoopDetectorCallback : public LoopDetectorCallback {
   MOCK_METHOD(void, onSuspiciousReadLoops, (uint64_t, NoReadReason));
 };
 
-class MockObserver : public Observer {
+class MockLegacyObserver : public LegacyObserver {
  public:
-  MockObserver() : Observer(Observer::Config()) {}
-  MockObserver(const Observer::Config& observerConfig)
-      : Observer(observerConfig) {}
+  MockLegacyObserver() : LegacyObserver(LegacyObserver::Config()) {}
+  explicit MockLegacyObserver(const LegacyObserver::Config& observerConfig)
+      : LegacyObserver(observerConfig) {}
   MOCK_METHOD((void), observerAttach, (QuicSocket*), (noexcept));
   MOCK_METHOD((void), observerDetach, (QuicSocket*), (noexcept));
   MOCK_METHOD((void), destroy, (QuicSocket*), (noexcept));
@@ -349,12 +349,14 @@ class MockObserver : public Observer {
       bool timeoutLoss) {
     return AllOf(
         testing::Field(
-            &Observer::LostPacket::lostByReorderThreshold,
+            &SocketObserverInterface::LostPacket::lostByReorderThreshold,
             testing::Eq(reorderLoss)),
         testing::Field(
-            &Observer::LostPacket::lostByTimeout, testing::Eq(timeoutLoss)),
+            &SocketObserverInterface::LostPacket::lostByTimeout,
+            testing::Eq(timeoutLoss)),
         testing::Field(
-            &Observer::LostPacket::packet, getLossPacketNum(packetNum)));
+            &SocketObserverInterface::LostPacket::packet,
+            getLossPacketNum(packetNum)));
   }
 
   static auto getStreamEventMatcher(

quic/api/test/QuicTransportBaseTest.cpp

@@ -3482,9 +3482,9 @@ TEST_F(QuicTransportImplTest, HandleKnobCallbacks) {
   auto conn = transport->transportConn;
 
   // attach an observer to the socket
-  Observer::Config config = {};
+  LegacyObserver::Config config = {};
   config.knobFrameEvents = true;
-  auto cb = std::make_unique<StrictMock<MockObserver>>(config);
+  auto cb = std::make_unique<StrictMock<MockLegacyObserver>>(config);
   EXPECT_CALL(*cb, observerAttach(transport.get()));
   transport->addObserver(cb.get());
   Mock::VerifyAndClearExpectations(cb.get());
@@ -3547,7 +3547,7 @@ TEST_F(QuicTransportImplTest, StreamWriteCallbackUnregister) {
 }
 
 TEST_F(QuicTransportImplTest, ObserverAttachRemove) {
-  auto cb = std::make_unique<StrictMock<MockObserver>>();
+  auto cb = std::make_unique<StrictMock<MockLegacyObserver>>();
   EXPECT_CALL(*cb, observerAttach(transport.get()));
   transport->addObserver(cb.get());
   EXPECT_THAT(transport->getObservers(), UnorderedElementsAre(cb.get()));
@@ -3558,13 +3558,13 @@ TEST_F(QuicTransportImplTest, ObserverAttachRemove) {
 }
 
 TEST_F(QuicTransportImplTest, ObserverAttachRemoveMultiple) {
-  auto cb1 = std::make_unique<StrictMock<MockObserver>>();
+  auto cb1 = std::make_unique<StrictMock<MockLegacyObserver>>();
   EXPECT_CALL(*cb1, observerAttach(transport.get()));
   transport->addObserver(cb1.get());
   Mock::VerifyAndClearExpectations(cb1.get());
   EXPECT_THAT(transport->getObservers(), UnorderedElementsAre(cb1.get()));
 
-  auto cb2 = std::make_unique<StrictMock<MockObserver>>();
+  auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>();
   EXPECT_CALL(*cb2, observerAttach(transport.get()));
   transport->addObserver(cb2.get());
   Mock::VerifyAndClearExpectations(cb2.get());
@@ -3583,13 +3583,13 @@ TEST_F(QuicTransportImplTest, ObserverAttachRemoveMultiple) {
 }
 
 TEST_F(QuicTransportImplTest, ObserverAttachRemoveMultipleReverse) {
-  auto cb1 = std::make_unique<StrictMock<MockObserver>>();
+  auto cb1 = std::make_unique<StrictMock<MockLegacyObserver>>();
   EXPECT_CALL(*cb1, observerAttach(transport.get()));
   transport->addObserver(cb1.get());
   Mock::VerifyAndClearExpectations(cb1.get());
   EXPECT_THAT(transport->getObservers(), UnorderedElementsAre(cb1.get()));
 
-  auto cb2 = std::make_unique<StrictMock<MockObserver>>();
+  auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>();
   EXPECT_CALL(*cb2, observerAttach(transport.get()));
   transport->addObserver(cb2.get());
   Mock::VerifyAndClearExpectations(cb2.get());
@@ -3608,13 +3608,13 @@ TEST_F(QuicTransportImplTest, ObserverAttachRemoveMultipleReverse) {
 }
 
 TEST_F(QuicTransportImplTest, ObserverRemoveMissing) {
-  auto cb = std::make_unique<StrictMock<MockObserver>>();
+  auto cb = std::make_unique<StrictMock<MockLegacyObserver>>();
   EXPECT_FALSE(transport->removeObserver(cb.get()));
   EXPECT_THAT(transport->getObservers(), IsEmpty());
 }
 
 TEST_F(QuicTransportImplTest, ObserverDestroyTransport) {
-  auto cb = std::make_unique<StrictMock<MockObserver>>();
+  auto cb = std::make_unique<StrictMock<MockLegacyObserver>>();
   EXPECT_CALL(*cb, observerAttach(transport.get()));
   transport->addObserver(cb.get());
   EXPECT_THAT(transport->getObservers(), UnorderedElementsAre(cb.get()));
@@ -3626,7 +3626,7 @@ TEST_F(QuicTransportImplTest, ObserverDestroyTransport) {
 }
 
 TEST_F(QuicTransportImplTest, ObserverCloseNoErrorThenDestroyTransport) {
-  auto cb = std::make_unique<StrictMock<MockObserver>>();
+  auto cb = std::make_unique<StrictMock<MockLegacyObserver>>();
   EXPECT_CALL(*cb, observerAttach(transport.get()));
   transport->addObserver(cb.get());
   EXPECT_THAT(transport->getObservers(), UnorderedElementsAre(cb.get()));
@@ -3645,7 +3645,7 @@ TEST_F(QuicTransportImplTest, ObserverCloseNoErrorThenDestroyTransport) {
 }
 
 TEST_F(QuicTransportImplTest, ObserverCloseWithErrorThenDestroyTransport) {
-  auto cb = std::make_unique<StrictMock<MockObserver>>();
+  auto cb = std::make_unique<StrictMock<MockLegacyObserver>>();
   EXPECT_CALL(*cb, observerAttach(transport.get()));
   transport->addObserver(cb.get());
   EXPECT_THAT(transport->getObservers(), UnorderedElementsAre(cb.get()));
@@ -3664,7 +3664,7 @@ TEST_F(QuicTransportImplTest, ObserverCloseWithErrorThenDestroyTransport) {
 }
 
 TEST_F(QuicTransportImplTest, ObserverDetachObserverImmediately) {
-  auto cb = std::make_unique<StrictMock<MockObserver>>();
+  auto cb = std::make_unique<StrictMock<MockLegacyObserver>>();
   EXPECT_CALL(*cb, observerAttach(transport.get()));
   transport->addObserver(cb.get());
   EXPECT_THAT(transport->getObservers(), UnorderedElementsAre(cb.get()));
@@ -3676,7 +3676,7 @@ TEST_F(QuicTransportImplTest, ObserverDetachObserverImmediately) {
 }
 
 TEST_F(QuicTransportImplTest, ObserverDetachObserverAfterTransportClose) {
-  auto cb = std::make_unique<StrictMock<MockObserver>>();
+  auto cb = std::make_unique<StrictMock<MockLegacyObserver>>();
   EXPECT_CALL(*cb, observerAttach(transport.get()));
   transport->addObserver(cb.get());
   EXPECT_THAT(transport->getObservers(), UnorderedElementsAre(cb.get()));
@@ -3694,7 +3694,7 @@ TEST_F(QuicTransportImplTest, ObserverDetachObserverAfterTransportClose) {
 TEST_F(
     QuicTransportImplTest,
     ObserverDetachObserverOnCloseDuringTransportDestroy) {
-  auto cb = std::make_unique<StrictMock<MockObserver>>();
+  auto cb = std::make_unique<StrictMock<MockLegacyObserver>>();
   EXPECT_CALL(*cb, observerAttach(transport.get()));
   transport->addObserver(cb.get());
   EXPECT_THAT(transport->getObservers(), UnorderedElementsAre(cb.get()));
@@ -3710,12 +3710,12 @@ TEST_F(
 }
 
 TEST_F(QuicTransportImplTest, ObserverMultipleAttachRemove) {
-  auto cb1 = std::make_unique<StrictMock<MockObserver>>();
+  auto cb1 = std::make_unique<StrictMock<MockLegacyObserver>>();
   EXPECT_CALL(*cb1, observerAttach(transport.get()));
   transport->addObserver(cb1.get());
   EXPECT_THAT(transport->getObservers(), UnorderedElementsAre(cb1.get()));
 
-  auto cb2 = std::make_unique<StrictMock<MockObserver>>();
+  auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>();
   EXPECT_CALL(*cb2, observerAttach(transport.get()));
   transport->addObserver(cb2.get());
   EXPECT_THAT(
@@ -3737,12 +3737,12 @@ TEST_F(QuicTransportImplTest, ObserverMultipleAttachRemove) {
 }
 
 TEST_F(QuicTransportImplTest, ObserverMultipleAttachDestroyTransport) {
-  auto cb1 = std::make_unique<StrictMock<MockObserver>>();
+  auto cb1 = std::make_unique<StrictMock<MockLegacyObserver>>();
   EXPECT_CALL(*cb1, observerAttach(transport.get()));
   transport->addObserver(cb1.get());
   EXPECT_THAT(transport->getObservers(), UnorderedElementsAre(cb1.get()));
 
-  auto cb2 = std::make_unique<StrictMock<MockObserver>>();
+  auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>();
   EXPECT_CALL(*cb2, observerAttach(transport.get()));
   transport->addObserver(cb2.get());
   EXPECT_THAT(
@@ -3759,9 +3759,9 @@ TEST_F(QuicTransportImplTest, ObserverMultipleAttachDestroyTransport) {
 }
 
 TEST_F(QuicTransportImplTest, ObserverDetachAndAttachEvb) {
-  Observer::Config config = {};
+  LegacyObserver::Config config = {};
   config.evbEvents = true;
-  auto cb = std::make_unique<StrictMock<MockObserver>>(config);
+  auto cb = std::make_unique<StrictMock<MockLegacyObserver>>(config);
   folly::EventBase evb2;
 
   EXPECT_CALL(*cb, observerAttach(transport.get()));

quic/api/test/QuicTransportTest.cpp

@@ -376,12 +376,13 @@ TEST_F(QuicTransportTest, ObserverNotAppLimitedWithNoWritableBytes) {
         return 0;
       }));
 
-  Observer::Config config = {};
+  LegacyObserver::Config config = {};
   config.packetsWrittenEvents = true;
   config.appRateLimitedEvents = true;
-  auto cb1 = std::make_unique<StrictMock<MockObserver>>(config);
-  auto cb2 = std::make_unique<StrictMock<MockObserver>>(config);
-  auto cb3 = std::make_unique<StrictMock<MockObserver>>(Observer::Config());
+  auto cb1 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
+  auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
+  auto cb3 = std::make_unique<StrictMock<MockLegacyObserver>>(
+      LegacyObserver::Config());
 
   EXPECT_CALL(*cb1, observerAttach(transport_.get()));
   EXPECT_CALL(*cb2, observerAttach(transport_.get()));
@@ -421,12 +422,13 @@ TEST_F(QuicTransportTest, ObserverNotAppLimitedWithLargeBuffer) {
   EXPECT_CALL(*rawCongestionController, getWritableBytes())
       .WillRepeatedly(Return(5000));
 
-  Observer::Config config = {};
+  LegacyObserver::Config config = {};
   config.packetsWrittenEvents = true;
   config.appRateLimitedEvents = true;
-  auto cb1 = std::make_unique<StrictMock<MockObserver>>(config);
-  auto cb2 = std::make_unique<StrictMock<MockObserver>>(config);
-  auto cb3 = std::make_unique<StrictMock<MockObserver>>(Observer::Config());
+  auto cb1 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
+  auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
+  auto cb3 = std::make_unique<StrictMock<MockLegacyObserver>>(
+      LegacyObserver::Config());
 
   EXPECT_CALL(*cb1, observerAttach(transport_.get()));
   EXPECT_CALL(*cb2, observerAttach(transport_.get()));
@@ -458,12 +460,13 @@ TEST_F(QuicTransportTest, ObserverNotAppLimitedWithLargeBuffer) {
 }
 
 TEST_F(QuicTransportTest, ObserverAppLimited) {
-  Observer::Config config = {};
+  LegacyObserver::Config config = {};
   config.packetsWrittenEvents = true;
   config.appRateLimitedEvents = true;
-  auto cb1 = std::make_unique<StrictMock<MockObserver>>(config);
-  auto cb2 = std::make_unique<StrictMock<MockObserver>>(config);
-  auto cb3 = std::make_unique<StrictMock<MockObserver>>(Observer::Config());
+  auto cb1 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
+  auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
+  auto cb3 = std::make_unique<StrictMock<MockLegacyObserver>>(
+      LegacyObserver::Config());
   EXPECT_CALL(*cb1, observerAttach(transport_.get()));
   EXPECT_CALL(*cb2, observerAttach(transport_.get()));
   EXPECT_CALL(*cb3, observerAttach(transport_.get()));
@@ -506,26 +509,27 @@ TEST_F(QuicTransportTest, ObserverAppLimited) {
 TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
   InSequence s;
 
-  Observer::Config config = {};
+  LegacyObserver::Config config = {};
   config.packetsWrittenEvents = true;
   config.appRateLimitedEvents = true;
-  auto cb1 = std::make_unique<StrictMock<MockObserver>>(config);
-  auto cb2 = std::make_unique<StrictMock<MockObserver>>(config);
-  auto cb3 = std::make_unique<StrictMock<MockObserver>>(Observer::Config());
+  auto cb1 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
+  auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
+  auto cb3 = std::make_unique<StrictMock<MockLegacyObserver>>(
+      LegacyObserver::Config());
   const auto invokeForAllObservers =
-      [&cb1, &cb2, &cb3](const std::function<void(MockObserver&)>& fn) {
+      [&cb1, &cb2, &cb3](const std::function<void(MockLegacyObserver&)>& fn) {
         fn(*cb1);
         fn(*cb2);
         fn(*cb3);
       };
   const auto invokeForEachObserverWithTestEvents =
-      [&cb1, &cb2](const std::function<void(MockObserver&)>& fn) {
+      [&cb1, &cb2](const std::function<void(MockLegacyObserver&)>& fn) {
         fn(*cb1);
         fn(*cb2);
       };
 
   // install observers
-  invokeForAllObservers(([this](MockObserver& observer) {
+  invokeForAllObservers(([this](MockLegacyObserver& observer) {
     EXPECT_CALL(observer, observerAttach(transport_.get()));
     transport_->addObserver(&observer);
   }));
@@ -547,25 +551,29 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
   {
     const auto writeEventMatcher = AllOf(
         testing::Property(
-            &Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(0)),
+            &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+            testing::SizeIs(0)),
         testing::Field(
-            &Observer::WriteEvent::writeCount, testing::Eq(writeNum)));
+            &SocketObserverInterface::WriteEvent::writeCount,
+            testing::Eq(writeNum)));
     const auto packetsWrittenEventMatcher = AllOf(
         testing::Field(
-            &Observer::PacketsWrittenEvent::numPacketsWritten, testing::Eq(1)),
+            &SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
+            testing::Eq(1)),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::
+                numAckElicitingPacketsWritten,
             testing::Eq(0)));
 
     invokeForEachObserverWithTestEvents(
-        ([this, &writeEventMatcher](MockObserver& observer) {
+        ([this, &writeEventMatcher](MockLegacyObserver& observer) {
           EXPECT_CALL(
               observer,
               startWritingFromAppLimited(transport_.get(), writeEventMatcher));
         }));
     invokeForEachObserverWithTestEvents(
         ([this, &writeEventMatcher, &packetsWrittenEventMatcher](
-             MockObserver& observer) {
+             MockLegacyObserver& observer) {
           EXPECT_CALL(
               observer,
               packetsWritten(
@@ -573,7 +581,7 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
                   AllOf(writeEventMatcher, packetsWrittenEventMatcher)));
         }));
     invokeForEachObserverWithTestEvents(
-        ([this, &writeEventMatcher](MockObserver& observer) {
+        ([this, &writeEventMatcher](MockLegacyObserver& observer) {
           EXPECT_CALL(
               observer, appRateLimited(transport_.get(), writeEventMatcher));
         }));
@@ -610,12 +618,14 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
     {
       const auto writeEventMatcher = AllOf(
           testing::Property(
-              &Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(0)),
+              &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+              testing::SizeIs(0)),
           testing::Field(
-              &Observer::WriteEvent::writeCount, testing::Eq(writeNum)));
+              &SocketObserverInterface::WriteEvent::writeCount,
+              testing::Eq(writeNum)));
 
       invokeForEachObserverWithTestEvents(([this, &writeEventMatcher](
-                                               MockObserver& observer) {
+                                               MockLegacyObserver& observer) {
         EXPECT_CALL(
             observer,
             startWritingFromAppLimited(transport_.get(), writeEventMatcher));
@@ -626,20 +636,23 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
     {
       const auto writeEventMatcher = AllOf(
           testing::Property(
-              &Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(5)),
+              &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+              testing::SizeIs(5)),
           testing::Field(
-              &Observer::WriteEvent::writeCount, testing::Eq(writeNum)));
+              &SocketObserverInterface::WriteEvent::writeCount,
+              testing::Eq(writeNum)));
       const auto packetsWrittenEventMatcher = AllOf(
           testing::Field(
-              &Observer::PacketsWrittenEvent::numPacketsWritten,
+              &SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
               testing::Eq(5)),
           testing::Field(
-              &Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
+              &SocketObserverInterface::PacketsWrittenEvent::
+                  numAckElicitingPacketsWritten,
               testing::Eq(5)));
 
       invokeForEachObserverWithTestEvents(
           ([this, &writeEventMatcher, &packetsWrittenEventMatcher](
-               MockObserver& observer) {
+               MockLegacyObserver& observer) {
             EXPECT_CALL(
                 observer,
                 packetsWritten(
@@ -654,20 +667,23 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
     {
       const auto writeEventMatcher = AllOf(
           testing::Property(
-              &Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(7)),
+              &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+              testing::SizeIs(7)),
           testing::Field(
-              &Observer::WriteEvent::writeCount, testing::Eq(writeNum)));
+              &SocketObserverInterface::WriteEvent::writeCount,
+              testing::Eq(writeNum)));
       const auto packetsWrittenEventMatcher = AllOf(
           testing::Field(
-              &Observer::PacketsWrittenEvent::numPacketsWritten,
+              &SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
               testing::Eq(2)),
           testing::Field(
-              &Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
+              &SocketObserverInterface::PacketsWrittenEvent::
+                  numAckElicitingPacketsWritten,
               testing::Eq(2)));
 
       invokeForEachObserverWithTestEvents(
           ([this, &writeEventMatcher, &packetsWrittenEventMatcher](
-               MockObserver& observer) {
+               MockLegacyObserver& observer) {
             EXPECT_CALL(
                 observer,
                 packetsWritten(
@@ -675,7 +691,7 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
                     AllOf(writeEventMatcher, packetsWrittenEventMatcher)));
           }));
       invokeForEachObserverWithTestEvents(
-          ([this, &writeEventMatcher](MockObserver& observer) {
+          ([this, &writeEventMatcher](MockLegacyObserver& observer) {
             EXPECT_CALL(
                 observer, appRateLimited(transport_.get(), writeEventMatcher));
           }));
@@ -710,12 +726,14 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
     {
       const auto writeEventMatcher = AllOf(
           testing::Property(
-              &Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(7)),
+              &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+              testing::SizeIs(7)),
           testing::Field(
-              &Observer::WriteEvent::writeCount, testing::Eq(writeNum)));
+              &SocketObserverInterface::WriteEvent::writeCount,
+              testing::Eq(writeNum)));
 
       invokeForEachObserverWithTestEvents(([this, &writeEventMatcher](
-                                               MockObserver& observer) {
+                                               MockLegacyObserver& observer) {
         EXPECT_CALL(
             observer,
             startWritingFromAppLimited(transport_.get(), writeEventMatcher));
@@ -727,9 +745,9 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
     {
       // older versions of gtest do not seem to accept lambdas for ResultOf
       // matcher, so define an std::function
-      std::function<uint64_t(const Observer::WriteEvent&)>
+      std::function<uint64_t(const SocketObserverInterface::WriteEvent&)>
           countPacketsWithAckFrames =
-              [](const Observer::WriteEvent& event) -> uint64_t {
+              [](const SocketObserverInterface::WriteEvent& event) -> uint64_t {
         uint64_t packetsWithAckFrames = 0;
         for (auto& outstandingPacket : event.outstandingPackets) {
           bool hasAckFrame = false;
@@ -749,20 +767,23 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
       const auto writeEventMatcher = AllOf(
           testing::ResultOf(countPacketsWithAckFrames, 1),
           testing::Property(
-              &Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(9)),
+              &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+              testing::SizeIs(9)),
           testing::Field(
-              &Observer::WriteEvent::writeCount, testing::Eq(writeNum)));
+              &SocketObserverInterface::WriteEvent::writeCount,
+              testing::Eq(writeNum)));
       const auto packetsWrittenEventMatcher = AllOf(
           testing::Field(
-              &Observer::PacketsWrittenEvent::numPacketsWritten,
+              &SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
               testing::Eq(2)),
           testing::Field(
-              &Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
+              &SocketObserverInterface::PacketsWrittenEvent::
+                  numAckElicitingPacketsWritten,
               testing::Eq(2)));
 
       invokeForEachObserverWithTestEvents(
           ([this, &writeEventMatcher, &packetsWrittenEventMatcher](
-               MockObserver& observer) {
+               MockLegacyObserver& observer) {
             EXPECT_CALL(
                 observer,
                 packetsWritten(
@@ -770,7 +791,7 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
                     AllOf(writeEventMatcher, packetsWrittenEventMatcher)));
           }));
       invokeForEachObserverWithTestEvents(
-          ([this, &writeEventMatcher](MockObserver& observer) {
+          ([this, &writeEventMatcher](MockLegacyObserver& observer) {
             EXPECT_CALL(
                 observer, appRateLimited(transport_.get(), writeEventMatcher));
           }));
@@ -810,25 +831,29 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
 
     const auto writeEventMatcher = AllOf(
         testing::Property(
-            &Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(9)),
+            &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+            testing::SizeIs(9)),
         testing::Field(
-            &Observer::WriteEvent::writeCount, testing::Eq(writeNum)));
+            &SocketObserverInterface::WriteEvent::writeCount,
+            testing::Eq(writeNum)));
     const auto packetsWrittenEventMatcher = AllOf(
         testing::Field(
-            &Observer::PacketsWrittenEvent::numPacketsWritten, testing::Eq(1)),
+            &SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
+            testing::Eq(1)),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::
+                numAckElicitingPacketsWritten,
             testing::Eq(0)));
 
     invokeForEachObserverWithTestEvents(
-        ([this, &writeEventMatcher](MockObserver& observer) {
+        ([this, &writeEventMatcher](MockLegacyObserver& observer) {
           EXPECT_CALL(
               observer,
               startWritingFromAppLimited(transport_.get(), writeEventMatcher));
         }));
     invokeForEachObserverWithTestEvents(
         ([this, &writeEventMatcher, &packetsWrittenEventMatcher](
-             MockObserver& observer) {
+             MockLegacyObserver& observer) {
           EXPECT_CALL(
               observer,
               packetsWritten(
@@ -836,7 +861,7 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
                   AllOf(writeEventMatcher, packetsWrittenEventMatcher)));
         }));
     invokeForEachObserverWithTestEvents(
-        ([this, &writeEventMatcher](MockObserver& observer) {
+        ([this, &writeEventMatcher](MockLegacyObserver& observer) {
           EXPECT_CALL(
               observer, appRateLimited(transport_.get(), writeEventMatcher));
         }));
@@ -856,10 +881,10 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
   transport_->updateWriteLooper(true);
   loopForWrites();
 
-  invokeForAllObservers(([this](MockObserver& observer) {
+  invokeForAllObservers(([this](MockLegacyObserver& observer) {
     EXPECT_CALL(observer, close(transport_.get(), _));
   }));
-  invokeForAllObservers(([this](MockObserver& observer) {
+  invokeForAllObservers(([this](MockLegacyObserver& observer) {
     EXPECT_CALL(observer, destroy(transport_.get()));
   }));
   transport_->close(folly::none);
@@ -869,25 +894,26 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCycleCheckDetails) {
 TEST_F(QuicTransportTest, ObserverPacketsWrittenCheckBytesSent) {
   InSequence s;
 
-  Observer::Config config = {};
+  LegacyObserver::Config config = {};
   config.packetsWrittenEvents = true;
-  auto cb1 = std::make_unique<StrictMock<MockObserver>>(config);
-  auto cb2 = std::make_unique<StrictMock<MockObserver>>(config);
-  auto cb3 = std::make_unique<StrictMock<MockObserver>>(Observer::Config());
+  auto cb1 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
+  auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
+  auto cb3 = std::make_unique<StrictMock<MockLegacyObserver>>(
+      LegacyObserver::Config());
   const auto invokeForAllObservers =
-      [&cb1, &cb2, &cb3](const std::function<void(MockObserver&)>& fn) {
+      [&cb1, &cb2, &cb3](const std::function<void(MockLegacyObserver&)>& fn) {
         fn(*cb1);
         fn(*cb2);
         fn(*cb3);
       };
   const auto invokeForEachObserverWithTestEvents =
-      [&cb1, &cb2](const std::function<void(MockObserver&)>& fn) {
+      [&cb1, &cb2](const std::function<void(MockLegacyObserver&)>& fn) {
         fn(*cb1);
         fn(*cb2);
       };
 
   // install observers
-  invokeForAllObservers(([this](MockObserver& observer) {
+  invokeForAllObservers(([this](MockLegacyObserver& observer) {
     EXPECT_CALL(observer, observerAttach(transport_.get()));
     transport_->addObserver(&observer);
   }));
@@ -903,21 +929,25 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCheckBytesSent) {
     // matcher
     const auto matcher = AllOf(
         testing::Property(
-            &Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(4)),
+            &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+            testing::SizeIs(4)),
         testing::Field(
-            &Observer::WriteEvent::writeCount, testing::Eq(writeNum)),
+            &SocketObserverInterface::WriteEvent::writeCount,
+            testing::Eq(writeNum)),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numPacketsWritten, testing::Eq(4)),
-        testing::Field(
-            &Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
             testing::Eq(4)),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numBytesWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::
+                numAckElicitingPacketsWritten,
+            testing::Eq(4)),
+        testing::Field(
+            &SocketObserverInterface::PacketsWrittenEvent::numBytesWritten,
             testing::Gt(4000)));
 
     invokeForEachObserverWithTestEvents(
         ([this, &matcher, oldTInfo = transport_->getTransportInfo()](
-             MockObserver& observer) {
+             MockLegacyObserver& observer) {
           EXPECT_CALL(observer, packetsWritten(transport_.get(), matcher))
               .WillOnce(([oldTInfo](const auto& socket, const auto& event) {
                 EXPECT_EQ(
@@ -940,21 +970,25 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCheckBytesSent) {
     // matcher
     const auto matcher = AllOf(
         testing::Property(
-            &Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(5)),
+            &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+            testing::SizeIs(5)),
         testing::Field(
-            &Observer::WriteEvent::writeCount, testing::Eq(writeNum)),
+            &SocketObserverInterface::WriteEvent::writeCount,
+            testing::Eq(writeNum)),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numPacketsWritten, testing::Eq(1)),
-        testing::Field(
-            &Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
             testing::Eq(1)),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numBytesWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::
+                numAckElicitingPacketsWritten,
+            testing::Eq(1)),
+        testing::Field(
+            &SocketObserverInterface::PacketsWrittenEvent::numBytesWritten,
             testing::Gt(1000)));
 
     invokeForEachObserverWithTestEvents(
         ([this, &matcher, oldTInfo = transport_->getTransportInfo()](
-             MockObserver& observer) {
+             MockLegacyObserver& observer) {
           EXPECT_CALL(observer, packetsWritten(transport_.get(), matcher))
               .WillOnce(([oldTInfo](const auto& socket, const auto& event) {
                 EXPECT_EQ(
@@ -976,20 +1010,25 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCheckBytesSent) {
     // matcher
     const auto matcher = AllOf(
         testing::Property(
-            &Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(5)),
+            &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+            testing::SizeIs(5)),
         testing::Field(
-            &Observer::WriteEvent::writeCount, testing::Eq(writeNum)),
+            &SocketObserverInterface::WriteEvent::writeCount,
+            testing::Eq(writeNum)),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numPacketsWritten, testing::Eq(1)),
+            &SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
+            testing::Eq(1)),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::
+                numAckElicitingPacketsWritten,
             testing::Eq(0)),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numBytesWritten, testing::Gt(0)));
+            &SocketObserverInterface::PacketsWrittenEvent::numBytesWritten,
+            testing::Gt(0)));
 
     invokeForEachObserverWithTestEvents(
         ([this, &matcher, oldTInfo = transport_->getTransportInfo()](
-             MockObserver& observer) {
+             MockLegacyObserver& observer) {
           EXPECT_CALL(observer, packetsWritten(transport_.get(), matcher))
               .WillOnce(([oldTInfo](const auto& socket, const auto& event) {
                 EXPECT_EQ(
@@ -1015,21 +1054,25 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCheckBytesSent) {
     // matcher
     const auto matcher = AllOf(
         testing::Property(
-            &Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(6)),
+            &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+            testing::SizeIs(6)),
         testing::Field(
-            &Observer::WriteEvent::writeCount, testing::Eq(writeNum)),
+            &SocketObserverInterface::WriteEvent::writeCount,
+            testing::Eq(writeNum)),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numPacketsWritten, testing::Eq(1)),
-        testing::Field(
-            &Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
             testing::Eq(1)),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numBytesWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::
+                numAckElicitingPacketsWritten,
+            testing::Eq(1)),
+        testing::Field(
+            &SocketObserverInterface::PacketsWrittenEvent::numBytesWritten,
             testing::Gt(1000)));
 
     invokeForEachObserverWithTestEvents(
         ([this, &matcher, oldTInfo = transport_->getTransportInfo()](
-             MockObserver& observer) {
+             MockLegacyObserver& observer) {
           EXPECT_CALL(observer, packetsWritten(transport_.get(), matcher))
               .WillOnce(([oldTInfo](const auto& socket, const auto& event) {
                 EXPECT_EQ(
@@ -1051,10 +1094,10 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCheckBytesSent) {
     loopForWrites();
   }
 
-  invokeForAllObservers(([this](MockObserver& observer) {
+  invokeForAllObservers(([this](MockLegacyObserver& observer) {
     EXPECT_CALL(observer, close(transport_.get(), _));
   }));
-  invokeForAllObservers(([this](MockObserver& observer) {
+  invokeForAllObservers(([this](MockLegacyObserver& observer) {
     EXPECT_CALL(observer, destroy(transport_.get()));
   }));
   transport_->close(folly::none);
@@ -1064,26 +1107,27 @@ TEST_F(QuicTransportTest, ObserverPacketsWrittenCheckBytesSent) {
 TEST_F(QuicTransportTest, ObserverWriteEventsCheckCwndPacketsWritable) {
   InSequence s;
 
-  Observer::Config config = {};
+  LegacyObserver::Config config = {};
   config.packetsWrittenEvents = true;
   config.appRateLimitedEvents = true;
-  auto cb1 = std::make_unique<StrictMock<MockObserver>>(config);
-  auto cb2 = std::make_unique<StrictMock<MockObserver>>(config);
-  auto cb3 = std::make_unique<StrictMock<MockObserver>>(Observer::Config());
+  auto cb1 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
+  auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>(config);
+  auto cb3 = std::make_unique<StrictMock<MockLegacyObserver>>(
+      LegacyObserver::Config());
   const auto invokeForAllObservers =
-      [&cb1, &cb2, &cb3](const std::function<void(MockObserver&)>& fn) {
+      [&cb1, &cb2, &cb3](const std::function<void(MockLegacyObserver&)>& fn) {
         fn(*cb1);
         fn(*cb2);
         fn(*cb3);
       };
   const auto invokeForEachObserverWithTestEvents =
-      [&cb1, &cb2](const std::function<void(MockObserver&)>& fn) {
+      [&cb1, &cb2](const std::function<void(MockLegacyObserver&)>& fn) {
         fn(*cb1);
         fn(*cb2);
       };
 
   // install observers
-  invokeForAllObservers(([this](MockObserver& observer) {
+  invokeForAllObservers(([this](MockLegacyObserver& observer) {
     EXPECT_CALL(observer, observerAttach(transport_.get()));
     transport_->addObserver(&observer);
   }));
@@ -1109,54 +1153,63 @@ TEST_F(QuicTransportTest, ObserverWriteEventsCheckCwndPacketsWritable) {
     // matcher for event from startWritingFromAppLimited
     const auto startWritingFromAppLimitedMatcher = AllOf(
         testing::Property(
-            &Observer::WriteEvent::getOutstandingPackets, testing::IsEmpty()),
+            &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+            testing::IsEmpty()),
         testing::Field(
-            &Observer::WriteEvent::writeCount, testing::Eq(writeNum)),
+            &SocketObserverInterface::WriteEvent::writeCount,
+            testing::Eq(writeNum)),
         testing::Field(
-            &Observer::WriteEvent::maybeCwndInBytes,
+            &SocketObserverInterface::WriteEvent::maybeCwndInBytes,
             testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
         testing::Field(
-            &Observer::WriteEvent::maybeWritableBytes,
+            &SocketObserverInterface::WriteEvent::maybeWritableBytes,
             testing::Eq(folly::Optional<uint64_t>(cwndInBytes))));
 
     // matcher for event from packetsWritten
     const auto packetsWrittenMatcher = AllOf(
         testing::Property(
-            &Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(4)),
+            &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+            testing::SizeIs(4)),
         testing::Field(
-            &Observer::WriteEvent::writeCount, testing::Eq(writeNum)),
+            &SocketObserverInterface::WriteEvent::writeCount,
+            testing::Eq(writeNum)),
         testing::Field(
-            &Observer::WriteEvent::maybeCwndInBytes,
+            &SocketObserverInterface::WriteEvent::maybeCwndInBytes,
             testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
         testing::Field( // precise check below
-            &Observer::WriteEvent::maybeWritableBytes,
+            &SocketObserverInterface::WriteEvent::maybeWritableBytes,
             testing::Lt(folly::Optional<uint64_t>(
                 upperBoundCurrentBytesWritable - bytesToWrite))),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numPacketsWritten, testing::Eq(4)),
-        testing::Field(
-            &Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
             testing::Eq(4)),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numBytesWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::
+                numAckElicitingPacketsWritten,
+            testing::Eq(4)),
+        testing::Field(
+            &SocketObserverInterface::PacketsWrittenEvent::numBytesWritten,
             testing::Gt(bytesToWrite)));
 
     // matcher for event from appRateLimited
     const auto appRateLimitedMatcher = AllOf(
         testing::Property(
-            &Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(4)),
+            &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+            testing::SizeIs(4)),
         testing::Field(
-            &Observer::WriteEvent::writeCount, testing::Eq(writeNum)),
+            &SocketObserverInterface::WriteEvent::writeCount,
+            testing::Eq(writeNum)),
         testing::Field(
-            &Observer::WriteEvent::maybeCwndInBytes,
+            &SocketObserverInterface::WriteEvent::maybeCwndInBytes,
             testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
         testing::Field( // precise check below
-            &Observer::WriteEvent::maybeWritableBytes,
+            &SocketObserverInterface::WriteEvent::maybeWritableBytes,
             testing::Lt(folly::Optional<uint64_t>(
                 upperBoundCurrentBytesWritable - bytesToWrite))));
 
     invokeForEachObserverWithTestEvents(
-        ([this, &startWritingFromAppLimitedMatcher](MockObserver& observer) {
+        ([this,
+          &startWritingFromAppLimitedMatcher](MockLegacyObserver& observer) {
           EXPECT_CALL(
               observer,
               startWritingFromAppLimited(
@@ -1167,7 +1220,8 @@ TEST_F(QuicTransportTest, ObserverWriteEventsCheckCwndPacketsWritable) {
         ([this,
           &packetsWrittenMatcher,
           cwndInBytes,
-          oldTInfo = transport_->getTransportInfo()](MockObserver& observer) {
+          oldTInfo =
+              transport_->getTransportInfo()](MockLegacyObserver& observer) {
           EXPECT_CALL(
               observer, packetsWritten(transport_.get(), packetsWrittenMatcher))
               .WillOnce(([cwndInBytes, oldTInfo](
@@ -1183,7 +1237,8 @@ TEST_F(QuicTransportTest, ObserverWriteEventsCheckCwndPacketsWritable) {
         ([this,
           &appRateLimitedMatcher,
           cwndInBytes,
-          oldTInfo = transport_->getTransportInfo()](MockObserver& observer) {
+          oldTInfo =
+              transport_->getTransportInfo()](MockLegacyObserver& observer) {
           EXPECT_CALL(
               observer, appRateLimited(transport_.get(), appRateLimitedMatcher))
               .WillOnce(([cwndInBytes, oldTInfo](
@@ -1214,90 +1269,99 @@ TEST_F(QuicTransportTest, ObserverWriteEventsCheckCwndPacketsWritable) {
     // matcher for event from startWritingFromAppLimited
     const auto startWritingFromAppLimitedMatcher = AllOf(
         testing::Property(
-            &Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(4)),
+            &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+            testing::SizeIs(4)),
         testing::Field(
-            &Observer::WriteEvent::writeCount, testing::Eq(writeNum)),
+            &SocketObserverInterface::WriteEvent::writeCount,
+            testing::Eq(writeNum)),
         testing::Field(
-            &Observer::WriteEvent::maybeCwndInBytes,
+            &SocketObserverInterface::WriteEvent::maybeCwndInBytes,
             testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
         testing::Field(
-            &Observer::WriteEvent::maybeWritableBytes,
+            &SocketObserverInterface::WriteEvent::maybeWritableBytes,
             testing::Lt(
                 folly::Optional<uint64_t>(upperBoundCurrentBytesWritable))));
 
     // matcher for event from packetsWritten
     const auto packetsWrittenMatcher = AllOf(
         testing::Property(
-            &Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(5)),
+            &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+            testing::SizeIs(5)),
         testing::Field(
-            &Observer::WriteEvent::writeCount, testing::Eq(writeNum)),
+            &SocketObserverInterface::WriteEvent::writeCount,
+            testing::Eq(writeNum)),
         testing::Field(
-            &Observer::WriteEvent::maybeCwndInBytes,
+            &SocketObserverInterface::WriteEvent::maybeCwndInBytes,
             testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
         testing::Field( // precise check below
-            &Observer::WriteEvent::maybeWritableBytes,
+            &SocketObserverInterface::WriteEvent::maybeWritableBytes,
             testing::Lt(folly::Optional<uint64_t>(
                 upperBoundCurrentBytesWritable - bytesToWrite))),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numPacketsWritten, testing::Eq(1)),
-        testing::Field(
-            &Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
             testing::Eq(1)),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numBytesWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::
+                numAckElicitingPacketsWritten,
+            testing::Eq(1)),
+        testing::Field(
+            &SocketObserverInterface::PacketsWrittenEvent::numBytesWritten,
             testing::Gt(bytesToWrite)));
 
     // matcher for event from appRateLimited
     const auto appRateLimitedMatcher = AllOf(
         testing::Property(
-            &Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(5)),
+            &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+            testing::SizeIs(5)),
         testing::Field(
-            &Observer::WriteEvent::writeCount, testing::Eq(writeNum)),
+            &SocketObserverInterface::WriteEvent::writeCount,
+            testing::Eq(writeNum)),
         testing::Field(
-            &Observer::WriteEvent::maybeCwndInBytes,
+            &SocketObserverInterface::WriteEvent::maybeCwndInBytes,
             testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
         testing::Field( // precise check below
-            &Observer::WriteEvent::maybeWritableBytes,
+            &SocketObserverInterface::WriteEvent::maybeWritableBytes,
             testing::Lt(folly::Optional<uint64_t>(
                 upperBoundCurrentBytesWritable - bytesToWrite))));
 
     invokeForEachObserverWithTestEvents(
-        ([this, &startWritingFromAppLimitedMatcher](MockObserver& observer) {
+        ([this,
+          &startWritingFromAppLimitedMatcher](MockLegacyObserver& observer) {
           EXPECT_CALL(
               observer,
               startWritingFromAppLimited(
                   transport_.get(), startWritingFromAppLimitedMatcher));
         }));
 
-    invokeForEachObserverWithTestEvents(
-        ([this,
-          &packetsWrittenMatcher,
-          oldTInfo = transport_->getTransportInfo()](MockObserver& observer) {
-          EXPECT_CALL(
-              observer, packetsWritten(transport_.get(), packetsWrittenMatcher))
-              .WillOnce(([oldTInfo](const auto& socket, const auto& event) {
-                EXPECT_EQ(
-                    oldTInfo.writableBytes -
-                        (socket->getTransportInfo().bytesSent -
-                         oldTInfo.bytesSent),
-                    event.maybeWritableBytes);
-              }));
-        }));
+    invokeForEachObserverWithTestEvents(([this,
+                                          &packetsWrittenMatcher,
+                                          oldTInfo =
+                                              transport_->getTransportInfo()](
+                                             MockLegacyObserver& observer) {
+      EXPECT_CALL(
+          observer, packetsWritten(transport_.get(), packetsWrittenMatcher))
+          .WillOnce(([oldTInfo](const auto& socket, const auto& event) {
+            EXPECT_EQ(
+                oldTInfo.writableBytes -
+                    (socket->getTransportInfo().bytesSent - oldTInfo.bytesSent),
+                event.maybeWritableBytes);
+          }));
+    }));
 
-    invokeForEachObserverWithTestEvents(
-        ([this,
-          &appRateLimitedMatcher,
-          oldTInfo = transport_->getTransportInfo()](MockObserver& observer) {
-          EXPECT_CALL(
-              observer, appRateLimited(transport_.get(), appRateLimitedMatcher))
-              .WillOnce(([oldTInfo](const auto& socket, const auto& event) {
-                EXPECT_EQ(
-                    oldTInfo.writableBytes -
-                        (socket->getTransportInfo().bytesSent -
-                         oldTInfo.bytesSent),
-                    event.maybeWritableBytes);
-              }));
-        }));
+    invokeForEachObserverWithTestEvents(([this,
+                                          &appRateLimitedMatcher,
+                                          oldTInfo =
+                                              transport_->getTransportInfo()](
+                                             MockLegacyObserver& observer) {
+      EXPECT_CALL(
+          observer, appRateLimited(transport_.get(), appRateLimitedMatcher))
+          .WillOnce(([oldTInfo](const auto& socket, const auto& event) {
+            EXPECT_EQ(
+                oldTInfo.writableBytes -
+                    (socket->getTransportInfo().bytesSent - oldTInfo.bytesSent),
+                event.maybeWritableBytes);
+          }));
+    }));
 
     auto stream = transport_->createBidirectionalStream().value();
     transport_->writeChain(
@@ -1311,10 +1375,10 @@ TEST_F(QuicTransportTest, ObserverWriteEventsCheckCwndPacketsWritable) {
     writeNum++;
   }
 
-  invokeForAllObservers(([this](MockObserver& observer) {
+  invokeForAllObservers(([this](MockLegacyObserver& observer) {
     EXPECT_CALL(observer, close(transport_.get(), _));
   }));
-  invokeForAllObservers(([this](MockObserver& observer) {
+  invokeForAllObservers(([this](MockLegacyObserver& observer) {
     EXPECT_CALL(observer, destroy(transport_.get()));
   }));
   transport_->close(folly::none);
@@ -1322,10 +1386,12 @@ TEST_F(QuicTransportTest, ObserverWriteEventsCheckCwndPacketsWritable) {
 }
 
 TEST_F(QuicTransportTest, ObserverStreamEventBidirectionalLocalOpenClose) {
-  Observer::Config configWithStreamEvents = {};
+  LegacyObserver::Config configWithStreamEvents = {};
   configWithStreamEvents.streamEvents = true;
-  auto cb1 = std::make_unique<StrictMock<MockObserver>>(configWithStreamEvents);
-  auto cb2 = std::make_unique<StrictMock<MockObserver>>(Observer::Config());
+  auto cb1 =
+      std::make_unique<StrictMock<MockLegacyObserver>>(configWithStreamEvents);
+  auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>(
+      LegacyObserver::Config());
   EXPECT_CALL(*cb1, observerAttach(transport_.get()));
   transport_->addObserver(cb1.get());
   EXPECT_CALL(*cb2, observerAttach(transport_.get()));
@@ -1334,7 +1400,7 @@ TEST_F(QuicTransportTest, ObserverStreamEventBidirectionalLocalOpenClose) {
       transport_->getObservers(), UnorderedElementsAre(cb1.get(), cb2.get()));
 
   const auto id = 0x01;
-  const auto streamEventMatcher = MockObserver::getStreamEventMatcher(
+  const auto streamEventMatcher = MockLegacyObserver::getStreamEventMatcher(
       id, StreamInitiator::Local, StreamDirectionality::Bidirectional);
 
   EXPECT_CALL(*cb1, streamOpened(transport_.get(), streamEventMatcher));
@@ -1363,10 +1429,12 @@ TEST_F(QuicTransportTest, ObserverStreamEventBidirectionalLocalOpenClose) {
 }
 
 TEST_F(QuicTransportTest, ObserverStreamEventBidirectionalRemoteOpenClose) {
-  Observer::Config configWithStreamEvents = {};
+  LegacyObserver::Config configWithStreamEvents = {};
   configWithStreamEvents.streamEvents = true;
-  auto cb1 = std::make_unique<StrictMock<MockObserver>>(configWithStreamEvents);
-  auto cb2 = std::make_unique<StrictMock<MockObserver>>(Observer::Config());
+  auto cb1 =
+      std::make_unique<StrictMock<MockLegacyObserver>>(configWithStreamEvents);
+  auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>(
+      LegacyObserver::Config());
   EXPECT_CALL(*cb1, observerAttach(transport_.get()));
   transport_->addObserver(cb1.get());
   EXPECT_CALL(*cb2, observerAttach(transport_.get()));
@@ -1375,7 +1443,7 @@ TEST_F(QuicTransportTest, ObserverStreamEventBidirectionalRemoteOpenClose) {
       transport_->getObservers(), UnorderedElementsAre(cb1.get(), cb2.get()));
 
   const auto id = 0x00;
-  const auto streamEventMatcher = MockObserver::getStreamEventMatcher(
+  const auto streamEventMatcher = MockLegacyObserver::getStreamEventMatcher(
       id, StreamInitiator::Remote, StreamDirectionality::Bidirectional);
 
   EXPECT_CALL(*cb1, streamOpened(transport_.get(), streamEventMatcher));
@@ -1404,10 +1472,12 @@ TEST_F(QuicTransportTest, ObserverStreamEventBidirectionalRemoteOpenClose) {
 }
 
 TEST_F(QuicTransportTest, ObserverStreamEventUnidirectionalLocalOpenClose) {
-  Observer::Config configWithStreamEvents = {};
+  LegacyObserver::Config configWithStreamEvents = {};
   configWithStreamEvents.streamEvents = true;
-  auto cb1 = std::make_unique<StrictMock<MockObserver>>(configWithStreamEvents);
-  auto cb2 = std::make_unique<StrictMock<MockObserver>>(Observer::Config());
+  auto cb1 =
+      std::make_unique<StrictMock<MockLegacyObserver>>(configWithStreamEvents);
+  auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>(
+      LegacyObserver::Config());
   EXPECT_CALL(*cb1, observerAttach(transport_.get()));
   transport_->addObserver(cb1.get());
   EXPECT_CALL(*cb2, observerAttach(transport_.get()));
@@ -1416,7 +1486,7 @@ TEST_F(QuicTransportTest, ObserverStreamEventUnidirectionalLocalOpenClose) {
       transport_->getObservers(), UnorderedElementsAre(cb1.get(), cb2.get()));
 
   const auto id = 0x03;
-  const auto streamEventMatcher = MockObserver::getStreamEventMatcher(
+  const auto streamEventMatcher = MockLegacyObserver::getStreamEventMatcher(
       id, StreamInitiator::Local, StreamDirectionality::Unidirectional);
 
   EXPECT_CALL(*cb1, streamOpened(transport_.get(), streamEventMatcher));
@@ -1445,10 +1515,12 @@ TEST_F(QuicTransportTest, ObserverStreamEventUnidirectionalLocalOpenClose) {
 }
 
 TEST_F(QuicTransportTest, ObserverStreamEventUnidirectionalRemoteOpenClose) {
-  Observer::Config configWithStreamEvents = {};
+  LegacyObserver::Config configWithStreamEvents = {};
   configWithStreamEvents.streamEvents = true;
-  auto cb1 = std::make_unique<StrictMock<MockObserver>>(configWithStreamEvents);
-  auto cb2 = std::make_unique<StrictMock<MockObserver>>(Observer::Config());
+  auto cb1 =
+      std::make_unique<StrictMock<MockLegacyObserver>>(configWithStreamEvents);
+  auto cb2 = std::make_unique<StrictMock<MockLegacyObserver>>(
+      LegacyObserver::Config());
   EXPECT_CALL(*cb1, observerAttach(transport_.get()));
   transport_->addObserver(cb1.get());
   EXPECT_CALL(*cb2, observerAttach(transport_.get()));
@@ -1457,7 +1529,7 @@ TEST_F(QuicTransportTest, ObserverStreamEventUnidirectionalRemoteOpenClose) {
       transport_->getObservers(), UnorderedElementsAre(cb1.get(), cb2.get()));
 
   const auto id = 0x02;
-  const auto streamEventMatcher = MockObserver::getStreamEventMatcher(
+  const auto streamEventMatcher = MockLegacyObserver::getStreamEventMatcher(
       id, StreamInitiator::Remote, StreamDirectionality::Unidirectional);
 
   EXPECT_CALL(*cb1, streamOpened(transport_.get(), streamEventMatcher));

quic/api/test/QuicTypedTransportTest.cpp

@@ -759,7 +759,7 @@ class QuicTypedTransportTestForObservers : public QuicTypedTransportTest<T> {
 
       if constexpr (std::is_same_v<T, QuicClientTransportAfterStartTestBase>) {
         return testing::Property(
-            &quic::Observer::AcksProcessedEvent::getAckEvents,
+            &quic::SocketObserverInterface::AcksProcessedEvent::getAckEvents,
             testing::ElementsAre(testing::AllOf(
                 // ack time, adjusted ack time, RTT not supported for client now
                 testing::Field(
@@ -775,7 +775,7 @@ class QuicTypedTransportTestForObservers : public QuicTypedTransportTest<T> {
                     testing::SizeIs(expectedNumAckedPackets)))));
       } else if constexpr (std::is_same_v<T, QuicServerTransportTestBase>) {
         return testing::Property(
-            &quic::Observer::AcksProcessedEvent::getAckEvents,
+            &quic::SocketObserverInterface::AcksProcessedEvent::getAckEvents,
             testing::ElementsAre(testing::AllOf(
                 testing::Field(&quic::AckEvent::ackTime, testing::Eq(ackTime)),
                 testing::Field(
@@ -823,12 +823,13 @@ class QuicTypedTransportTestForObservers : public QuicTypedTransportTest<T> {
       const StreamDirectionality streamDirectionality) {
     return testing::AllOf(
         testing::Field(
-            &quic::Observer::StreamEvent::streamId, testing::Eq(streamId)),
+            &quic::SocketObserverInterface::StreamEvent::streamId,
+            testing::Eq(streamId)),
         testing::Field(
-            &quic::Observer::StreamEvent::streamInitiator,
+            &quic::SocketObserverInterface::StreamEvent::streamInitiator,
             testing::Eq(streamInitiator)),
         testing::Field(
-            &quic::Observer::StreamEvent::streamDirectionality,
+            &quic::SocketObserverInterface::StreamEvent::streamDirectionality,
             testing::Eq(streamDirectionality)));
   }
 };
@@ -840,7 +841,7 @@ TYPED_TEST_SUITE(
 
 TYPED_TEST(QuicTypedTransportTestForObservers, Attach) {
   auto transport = this->getTransport();
-  auto observer = std::make_unique<StrictMock<MockObserver>>();
+  auto observer = std::make_unique<StrictMock<MockLegacyObserver>>();
 
   EXPECT_CALL(*observer, observerAttach(transport));
   transport->addObserver(observer.get());
@@ -855,7 +856,7 @@ TYPED_TEST(
     QuicTypedTransportTestForObservers,
     CloseNoErrorThenDestroyTransport) {
   auto transport = this->getTransport();
-  auto observer = std::make_unique<StrictMock<MockObserver>>();
+  auto observer = std::make_unique<StrictMock<MockLegacyObserver>>();
 
   EXPECT_CALL(*observer, observerAttach(transport));
   transport->addObserver(observer.get());
@@ -878,7 +879,7 @@ TYPED_TEST(
     QuicTypedTransportTestForObservers,
     CloseWithErrorThenDestroyTransport) {
   auto transport = this->getTransport();
-  auto observer = std::make_unique<StrictMock<MockObserver>>();
+  auto observer = std::make_unique<StrictMock<MockLegacyObserver>>();
 
   EXPECT_CALL(*observer, observerAttach(transport));
   transport->addObserver(observer.get());
@@ -898,15 +899,18 @@ TYPED_TEST(
 }
 
 TYPED_TEST(QuicTypedTransportTestForObservers, StreamEventsLocalOpenedStream) {
-  MockObserver::Config configWithStreamEventsEnabled;
+  MockLegacyObserver::Config configWithStreamEventsEnabled;
   configWithStreamEventsEnabled.streamEvents = true;
 
   auto transport = this->getTransport();
-  auto observerWithNoStreamEvents = std::make_unique<NiceMock<MockObserver>>();
+  auto observerWithNoStreamEvents =
+      std::make_unique<NiceMock<MockLegacyObserver>>();
   auto observerWithStreamEvents1 =
-      std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(
+          configWithStreamEventsEnabled);
   auto observerWithStreamEvents2 =
-      std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(
+          configWithStreamEventsEnabled);
 
   EXPECT_CALL(*observerWithNoStreamEvents, observerAttach(transport));
   transport->addObserver(observerWithNoStreamEvents.get());
@@ -974,15 +978,18 @@ TYPED_TEST(QuicTypedTransportTestForObservers, StreamEventsLocalOpenedStream) {
 TYPED_TEST(
     QuicTypedTransportTestForObservers,
     StreamEventsLocalOpenedStreamImmediateEofLocal) {
-  MockObserver::Config configWithStreamEventsEnabled;
+  MockLegacyObserver::Config configWithStreamEventsEnabled;
   configWithStreamEventsEnabled.streamEvents = true;
 
   auto transport = this->getTransport();
-  auto observerWithNoStreamEvents = std::make_unique<NiceMock<MockObserver>>();
+  auto observerWithNoStreamEvents =
+      std::make_unique<NiceMock<MockLegacyObserver>>();
   auto observerWithStreamEvents1 =
-      std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(
+          configWithStreamEventsEnabled);
   auto observerWithStreamEvents2 =
-      std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(
+          configWithStreamEventsEnabled);
 
   EXPECT_CALL(*observerWithNoStreamEvents, observerAttach(transport));
   transport->addObserver(observerWithNoStreamEvents.get());
@@ -1042,15 +1049,18 @@ TYPED_TEST(
 TYPED_TEST(
     QuicTypedTransportTestForObservers,
     StreamEventsLocalOpenedStreamImmediateEofLocalRemote) {
-  MockObserver::Config configWithStreamEventsEnabled;
+  MockLegacyObserver::Config configWithStreamEventsEnabled;
   configWithStreamEventsEnabled.streamEvents = true;
 
   auto transport = this->getTransport();
-  auto observerWithNoStreamEvents = std::make_unique<NiceMock<MockObserver>>();
+  auto observerWithNoStreamEvents =
+      std::make_unique<NiceMock<MockLegacyObserver>>();
   auto observerWithStreamEvents1 =
-      std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(
+          configWithStreamEventsEnabled);
   auto observerWithStreamEvents2 =
-      std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(
+          configWithStreamEventsEnabled);
 
   EXPECT_CALL(*observerWithNoStreamEvents, observerAttach(transport));
   transport->addObserver(observerWithNoStreamEvents.get());
@@ -1105,15 +1115,18 @@ TYPED_TEST(
 }
 
 TYPED_TEST(QuicTypedTransportTestForObservers, StreamEventsPeerOpenedStream) {
-  MockObserver::Config configWithStreamEventsEnabled;
+  MockLegacyObserver::Config configWithStreamEventsEnabled;
   configWithStreamEventsEnabled.streamEvents = true;
 
   auto transport = this->getTransport();
-  auto observerWithNoStreamEvents = std::make_unique<NiceMock<MockObserver>>();
+  auto observerWithNoStreamEvents =
+      std::make_unique<NiceMock<MockLegacyObserver>>();
   auto observerWithStreamEvents1 =
-      std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(
+          configWithStreamEventsEnabled);
   auto observerWithStreamEvents2 =
-      std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(
+          configWithStreamEventsEnabled);
 
   EXPECT_CALL(*observerWithNoStreamEvents, observerAttach(transport));
   transport->addObserver(observerWithNoStreamEvents.get());
@@ -1175,15 +1188,18 @@ TYPED_TEST(QuicTypedTransportTestForObservers, StreamEventsPeerOpenedStream) {
 TYPED_TEST(
     QuicTypedTransportTestForObservers,
     StreamEventsPeerOpenedStreamImmediateEofRemote) {
-  MockObserver::Config configWithStreamEventsEnabled;
+  MockLegacyObserver::Config configWithStreamEventsEnabled;
   configWithStreamEventsEnabled.streamEvents = true;
 
   auto transport = this->getTransport();
-  auto observerWithNoStreamEvents = std::make_unique<NiceMock<MockObserver>>();
+  auto observerWithNoStreamEvents =
+      std::make_unique<NiceMock<MockLegacyObserver>>();
   auto observerWithStreamEvents1 =
-      std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(
+          configWithStreamEventsEnabled);
   auto observerWithStreamEvents2 =
-      std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(
+          configWithStreamEventsEnabled);
 
   EXPECT_CALL(*observerWithNoStreamEvents, observerAttach(transport));
   transport->addObserver(observerWithNoStreamEvents.get());
@@ -1241,15 +1257,18 @@ TYPED_TEST(
 TYPED_TEST(
     QuicTypedTransportTestForObservers,
     StreamEventsPeerOpenedStreamImmediateEofLocalRemote) {
-  MockObserver::Config configWithStreamEventsEnabled;
+  MockLegacyObserver::Config configWithStreamEventsEnabled;
   configWithStreamEventsEnabled.streamEvents = true;
 
   auto transport = this->getTransport();
-  auto observerWithNoStreamEvents = std::make_unique<NiceMock<MockObserver>>();
+  auto observerWithNoStreamEvents =
+      std::make_unique<NiceMock<MockLegacyObserver>>();
   auto observerWithStreamEvents1 =
-      std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(
+          configWithStreamEventsEnabled);
   auto observerWithStreamEvents2 =
-      std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(
+          configWithStreamEventsEnabled);
 
   EXPECT_CALL(*observerWithNoStreamEvents, observerAttach(transport));
   transport->addObserver(observerWithNoStreamEvents.get());
@@ -1301,15 +1320,18 @@ TYPED_TEST(
 TYPED_TEST(
     QuicTypedTransportTestForObservers,
     StreamEventsPeerOpenedStreamStopSendingPlusRstTriggersRst) {
-  MockObserver::Config configWithStreamEventsEnabled;
+  MockLegacyObserver::Config configWithStreamEventsEnabled;
   configWithStreamEventsEnabled.streamEvents = true;
 
   auto transport = this->getTransport();
-  auto observerWithNoStreamEvents = std::make_unique<NiceMock<MockObserver>>();
+  auto observerWithNoStreamEvents =
+      std::make_unique<NiceMock<MockLegacyObserver>>();
   auto observerWithStreamEvents1 =
-      std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(
+          configWithStreamEventsEnabled);
   auto observerWithStreamEvents2 =
-      std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(
+          configWithStreamEventsEnabled);
 
   EXPECT_CALL(*observerWithNoStreamEvents, observerAttach(transport));
   transport->addObserver(observerWithNoStreamEvents.get());
@@ -1385,15 +1407,18 @@ TYPED_TEST(
 TYPED_TEST(
     QuicTypedTransportTestForObservers,
     StreamEventsPeerOpenedStreamStopSendingPlusRstTriggersRstBytesInFlight) {
-  MockObserver::Config configWithStreamEventsEnabled;
+  MockLegacyObserver::Config configWithStreamEventsEnabled;
   configWithStreamEventsEnabled.streamEvents = true;
 
   auto transport = this->getTransport();
-  auto observerWithNoStreamEvents = std::make_unique<NiceMock<MockObserver>>();
+  auto observerWithNoStreamEvents =
+      std::make_unique<NiceMock<MockLegacyObserver>>();
   auto observerWithStreamEvents1 =
-      std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(
+          configWithStreamEventsEnabled);
   auto observerWithStreamEvents2 =
-      std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(
+          configWithStreamEventsEnabled);
 
   EXPECT_CALL(*observerWithNoStreamEvents, observerAttach(transport));
   transport->addObserver(observerWithNoStreamEvents.get());
@@ -1467,15 +1492,18 @@ TYPED_TEST(
 TYPED_TEST(
     QuicTypedTransportTestForObservers,
     StreamEventsPeerOpenedStreamImmediateEorStopSendingTriggersRstBytesInFlight) {
-  MockObserver::Config configWithStreamEventsEnabled;
+  MockLegacyObserver::Config configWithStreamEventsEnabled;
   configWithStreamEventsEnabled.streamEvents = true;
 
   auto transport = this->getTransport();
-  auto observerWithNoStreamEvents = std::make_unique<NiceMock<MockObserver>>();
+  auto observerWithNoStreamEvents =
+      std::make_unique<NiceMock<MockLegacyObserver>>();
   auto observerWithStreamEvents1 =
-      std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(
+          configWithStreamEventsEnabled);
   auto observerWithStreamEvents2 =
-      std::make_unique<NiceMock<MockObserver>>(configWithStreamEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(
+          configWithStreamEventsEnabled);
 
   EXPECT_CALL(*observerWithNoStreamEvents, observerAttach(transport));
   transport->addObserver(observerWithNoStreamEvents.get());
@@ -1560,16 +1588,16 @@ TYPED_TEST(
       std::make_unique<StaticCwndCongestionController>(
           StaticCwndCongestionController::CwndInBytes(cwndInBytes));
 
-  MockObserver::Config configWithEventsEnabled;
+  MockLegacyObserver::Config configWithEventsEnabled;
   configWithEventsEnabled.appRateLimitedEvents = true;
   configWithEventsEnabled.packetsWrittenEvents = true;
 
   auto transport = this->getTransport();
-  auto observerWithNoEvents = std::make_unique<NiceMock<MockObserver>>();
+  auto observerWithNoEvents = std::make_unique<NiceMock<MockLegacyObserver>>();
   auto observerWithEvents1 =
-      std::make_unique<NiceMock<MockObserver>>(configWithEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithEventsEnabled);
   auto observerWithEvents2 =
-      std::make_unique<NiceMock<MockObserver>>(configWithEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithEventsEnabled);
 
   EXPECT_CALL(*observerWithNoEvents, observerAttach(transport));
   transport->addObserver(observerWithNoEvents.get());
@@ -1599,14 +1627,16 @@ TYPED_TEST(
     // matcher for event from startWritingFromAppLimited
     const auto startWritingFromAppLimitedMatcher = AllOf(
         testing::Property(
-            &Observer::WriteEvent::getOutstandingPackets, testing::IsEmpty()),
+            &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+            testing::IsEmpty()),
         testing::Field(
-            &Observer::WriteEvent::writeCount, testing::Eq(writeCount)),
+            &SocketObserverInterface::WriteEvent::writeCount,
+            testing::Eq(writeCount)),
         testing::Field(
-            &Observer::WriteEvent::maybeCwndInBytes,
+            &SocketObserverInterface::WriteEvent::maybeCwndInBytes,
             testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
         testing::Field(
-            &Observer::WriteEvent::maybeWritableBytes,
+            &SocketObserverInterface::WriteEvent::maybeWritableBytes,
             testing::Eq(folly::Optional<uint64_t>(cwndInBytes))));
     EXPECT_CALL(*observerWithNoEvents, startWritingFromAppLimited(_, _))
         .Times(0);
@@ -1622,22 +1652,26 @@ TYPED_TEST(
     // matcher for event from packetsWritten
     const auto packetsWrittenMatcher = AllOf(
         testing::Property(
-            &Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(1)),
+            &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+            testing::SizeIs(1)),
         testing::Field(
-            &Observer::WriteEvent::writeCount, testing::Eq(writeCount)),
+            &SocketObserverInterface::WriteEvent::writeCount,
+            testing::Eq(writeCount)),
         testing::Field(
-            &Observer::WriteEvent::maybeCwndInBytes,
+            &SocketObserverInterface::WriteEvent::maybeCwndInBytes,
             testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
         testing::Field( // precise check in WillOnce()
-            &Observer::WriteEvent::maybeWritableBytes,
+            &SocketObserverInterface::WriteEvent::maybeWritableBytes,
             testing::Lt(folly::Optional<uint64_t>(cwndInBytes - strLength))),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numPacketsWritten, testing::Eq(1)),
+            &SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
+            testing::Eq(1)),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::
+                numAckElicitingPacketsWritten,
             testing::Eq(1)),
         testing::Field( // precise check in WillOnce()
-            &Observer::PacketsWrittenEvent::numBytesWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::numBytesWritten,
             testing::Gt(strLength)));
     EXPECT_CALL(*observerWithNoEvents, packetsWritten(_, _)).Times(0);
     EXPECT_CALL(
@@ -1668,14 +1702,16 @@ TYPED_TEST(
     // matcher for event from appRateLimited
     const auto appRateLimitedMatcher = AllOf(
         testing::Property(
-            &Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(1)),
+            &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+            testing::SizeIs(1)),
         testing::Field(
-            &Observer::WriteEvent::writeCount, testing::Eq(writeCount)),
+            &SocketObserverInterface::WriteEvent::writeCount,
+            testing::Eq(writeCount)),
         testing::Field(
-            &Observer::WriteEvent::maybeCwndInBytes,
+            &SocketObserverInterface::WriteEvent::maybeCwndInBytes,
             testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
         testing::Field( // precise check below
-            &Observer::WriteEvent::maybeWritableBytes,
+            &SocketObserverInterface::WriteEvent::maybeWritableBytes,
             testing::Lt(folly::Optional<uint64_t>(cwndInBytes - strLength))));
 
     EXPECT_CALL(*observerWithNoEvents, appRateLimited(_, _)).Times(0);
@@ -1736,16 +1772,16 @@ TYPED_TEST(
       std::make_unique<StaticCwndCongestionController>(
           StaticCwndCongestionController::CwndInBytes(cwndInBytes));
 
-  MockObserver::Config configWithEventsEnabled;
+  MockLegacyObserver::Config configWithEventsEnabled;
   configWithEventsEnabled.appRateLimitedEvents = true;
   configWithEventsEnabled.packetsWrittenEvents = true;
 
   auto transport = this->getTransport();
-  auto observerWithNoEvents = std::make_unique<NiceMock<MockObserver>>();
+  auto observerWithNoEvents = std::make_unique<NiceMock<MockLegacyObserver>>();
   auto observerWithEvents1 =
-      std::make_unique<NiceMock<MockObserver>>(configWithEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithEventsEnabled);
   auto observerWithEvents2 =
-      std::make_unique<NiceMock<MockObserver>>(configWithEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithEventsEnabled);
 
   EXPECT_CALL(*observerWithNoEvents, observerAttach(transport));
   transport->addObserver(observerWithNoEvents.get());
@@ -1777,14 +1813,16 @@ TYPED_TEST(
     // matcher for event from startWritingFromAppLimited
     const auto startWritingFromAppLimitedMatcher = AllOf(
         testing::Property(
-            &Observer::WriteEvent::getOutstandingPackets, testing::IsEmpty()),
+            &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+            testing::IsEmpty()),
         testing::Field(
-            &Observer::WriteEvent::writeCount, testing::Eq(writeCount)),
+            &SocketObserverInterface::WriteEvent::writeCount,
+            testing::Eq(writeCount)),
         testing::Field(
-            &Observer::WriteEvent::maybeCwndInBytes,
+            &SocketObserverInterface::WriteEvent::maybeCwndInBytes,
             testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
         testing::Field(
-            &Observer::WriteEvent::maybeWritableBytes,
+            &SocketObserverInterface::WriteEvent::maybeWritableBytes,
             testing::Eq(folly::Optional<uint64_t>(cwndInBytes))));
     EXPECT_CALL(*observerWithNoEvents, startWritingFromAppLimited(_, _))
         .Times(0);
@@ -1800,22 +1838,26 @@ TYPED_TEST(
     // matcher for event from packetsWritten
     const auto packetsWrittenMatcher = AllOf(
         testing::Property(
-            &Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(1)),
+            &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+            testing::SizeIs(1)),
         testing::Field(
-            &Observer::WriteEvent::writeCount, testing::Eq(writeCount)),
+            &SocketObserverInterface::WriteEvent::writeCount,
+            testing::Eq(writeCount)),
         testing::Field(
-            &Observer::WriteEvent::maybeCwndInBytes,
+            &SocketObserverInterface::WriteEvent::maybeCwndInBytes,
             testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
         testing::Field( // precise check in WillOnce()
-            &Observer::WriteEvent::maybeWritableBytes,
+            &SocketObserverInterface::WriteEvent::maybeWritableBytes,
             testing::Eq(folly::Optional<uint64_t>(0))),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numPacketsWritten, testing::Eq(1)),
+            &SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
+            testing::Eq(1)),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::
+                numAckElicitingPacketsWritten,
             testing::Eq(1)),
         testing::Field( // precise check in WillOnce(), expect overshoot CWND
-            &Observer::PacketsWrittenEvent::numBytesWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::numBytesWritten,
             testing::AllOf(testing::Gt(bufLength), testing::Gt(cwndInBytes))));
     EXPECT_CALL(*observerWithNoEvents, packetsWritten(_, _)).Times(0);
     EXPECT_CALL(
@@ -1880,16 +1922,16 @@ TYPED_TEST(
       std::make_unique<StaticCwndCongestionController>(
           StaticCwndCongestionController::CwndInBytes(cwndInBytes));
 
-  MockObserver::Config configWithEventsEnabled;
+  MockLegacyObserver::Config configWithEventsEnabled;
   configWithEventsEnabled.appRateLimitedEvents = true;
   configWithEventsEnabled.packetsWrittenEvents = true;
 
   auto transport = this->getTransport();
-  auto observerWithNoEvents = std::make_unique<NiceMock<MockObserver>>();
+  auto observerWithNoEvents = std::make_unique<NiceMock<MockLegacyObserver>>();
   auto observerWithEvents1 =
-      std::make_unique<NiceMock<MockObserver>>(configWithEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithEventsEnabled);
   auto observerWithEvents2 =
-      std::make_unique<NiceMock<MockObserver>>(configWithEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithEventsEnabled);
 
   EXPECT_CALL(*observerWithNoEvents, observerAttach(transport));
   transport->addObserver(observerWithNoEvents.get());
@@ -1922,14 +1964,16 @@ TYPED_TEST(
     // matcher for event from startWritingFromAppLimited
     const auto startWritingFromAppLimitedMatcher = AllOf(
         testing::Property(
-            &Observer::WriteEvent::getOutstandingPackets, testing::IsEmpty()),
+            &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+            testing::IsEmpty()),
         testing::Field(
-            &Observer::WriteEvent::writeCount, testing::Eq(writeCount)),
+            &SocketObserverInterface::WriteEvent::writeCount,
+            testing::Eq(writeCount)),
         testing::Field(
-            &Observer::WriteEvent::maybeCwndInBytes,
+            &SocketObserverInterface::WriteEvent::maybeCwndInBytes,
             testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
         testing::Field(
-            &Observer::WriteEvent::maybeWritableBytes,
+            &SocketObserverInterface::WriteEvent::maybeWritableBytes,
             testing::Eq(folly::Optional<uint64_t>(cwndInBytes))));
     EXPECT_CALL(*observerWithNoEvents, startWritingFromAppLimited(_, _))
         .Times(0);
@@ -1945,24 +1989,26 @@ TYPED_TEST(
     // matcher for event from packetsWritten
     const auto packetsWrittenMatcher = AllOf(
         testing::Property(
-            &Observer::WriteEvent::getOutstandingPackets,
+            &SocketObserverInterface::WriteEvent::getOutstandingPackets,
             testing::SizeIs(packetsExpectedWritten)),
         testing::Field(
-            &Observer::WriteEvent::writeCount, testing::Eq(writeCount)),
+            &SocketObserverInterface::WriteEvent::writeCount,
+            testing::Eq(writeCount)),
         testing::Field(
-            &Observer::WriteEvent::maybeCwndInBytes,
+            &SocketObserverInterface::WriteEvent::maybeCwndInBytes,
             testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
         testing::Field( // precise check in WillOnce()
-            &Observer::WriteEvent::maybeWritableBytes,
+            &SocketObserverInterface::WriteEvent::maybeWritableBytes,
             testing::Eq(folly::Optional<uint64_t>(0))), // CWND exhausted
         testing::Field(
-            &Observer::PacketsWrittenEvent::numPacketsWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
             testing::Eq(packetsExpectedWritten)),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::
+                numAckElicitingPacketsWritten,
             testing::Eq(packetsExpectedWritten)),
         testing::Field( // precise check in WillOnce()
-            &Observer::PacketsWrittenEvent::numBytesWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::numBytesWritten,
             testing::Ge(cwndInBytes))); // full CWND written
     EXPECT_CALL(*observerWithNoEvents, packetsWritten(_, _)).Times(0);
     EXPECT_CALL(
@@ -2012,24 +2058,26 @@ TYPED_TEST(
     // matcher for event from packetsWritten
     const auto packetsWrittenMatcher = AllOf(
         testing::Property(
-            &Observer::WriteEvent::getOutstandingPackets,
+            &SocketObserverInterface::WriteEvent::getOutstandingPackets,
             testing::SizeIs(packetsExpectedWritten)),
         testing::Field(
-            &Observer::WriteEvent::writeCount, testing::Eq(writeCount)),
+            &SocketObserverInterface::WriteEvent::writeCount,
+            testing::Eq(writeCount)),
         testing::Field(
-            &Observer::WriteEvent::maybeCwndInBytes,
+            &SocketObserverInterface::WriteEvent::maybeCwndInBytes,
             testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
         testing::Field( // precise check in WillOnce()
-            &Observer::WriteEvent::maybeWritableBytes,
+            &SocketObserverInterface::WriteEvent::maybeWritableBytes,
             testing::Lt(folly::Optional<uint64_t>(cwndInBytes))),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numPacketsWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
             testing::Eq(packetsExpectedWritten)),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::
+                numAckElicitingPacketsWritten,
             testing::Eq(packetsExpectedWritten)),
         testing::Field( // precise check in WillOnce()
-            &Observer::PacketsWrittenEvent::numBytesWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::numBytesWritten,
             testing::Lt(cwndInBytes)));
     EXPECT_CALL(*observerWithNoEvents, packetsWritten(_, _)).Times(0);
     EXPECT_CALL(
@@ -2060,15 +2108,16 @@ TYPED_TEST(
     // matcher for event from appRateLimited
     const auto appRateLimitedMatcher = AllOf(
         testing::Property(
-            &Observer::WriteEvent::getOutstandingPackets,
+            &SocketObserverInterface::WriteEvent::getOutstandingPackets,
             testing::SizeIs(packetsExpectedWritten)),
         testing::Field(
-            &Observer::WriteEvent::writeCount, testing::Eq(writeCount)),
+            &SocketObserverInterface::WriteEvent::writeCount,
+            testing::Eq(writeCount)),
         testing::Field(
-            &Observer::WriteEvent::maybeCwndInBytes,
+            &SocketObserverInterface::WriteEvent::maybeCwndInBytes,
             testing::Eq(folly::Optional<uint64_t>(cwndInBytes))),
         testing::Field( // precise check in WillOnce()
-            &Observer::WriteEvent::maybeWritableBytes,
+            &SocketObserverInterface::WriteEvent::maybeWritableBytes,
             testing::Lt(folly::Optional<uint64_t>(cwndInBytes))));
     EXPECT_CALL(*observerWithNoEvents, appRateLimited(_, _)).Times(0);
     EXPECT_CALL(
@@ -2119,16 +2168,16 @@ TYPED_TEST(
   // remove congestion controller
   this->getNonConstConn().congestionController = nullptr;
 
-  MockObserver::Config configWithEventsEnabled;
+  MockLegacyObserver::Config configWithEventsEnabled;
   configWithEventsEnabled.appRateLimitedEvents = true;
   configWithEventsEnabled.packetsWrittenEvents = true;
 
   auto transport = this->getTransport();
-  auto observerWithNoEvents = std::make_unique<NiceMock<MockObserver>>();
+  auto observerWithNoEvents = std::make_unique<NiceMock<MockLegacyObserver>>();
   auto observerWithEvents1 =
-      std::make_unique<NiceMock<MockObserver>>(configWithEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithEventsEnabled);
   auto observerWithEvents2 =
-      std::make_unique<NiceMock<MockObserver>>(configWithEventsEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithEventsEnabled);
 
   EXPECT_CALL(*observerWithNoEvents, observerAttach(transport));
   transport->addObserver(observerWithNoEvents.get());
@@ -2166,22 +2215,26 @@ TYPED_TEST(
     // matcher for event from packetsWritten
     const auto packetsWrittenMatcher = AllOf(
         testing::Property(
-            &Observer::WriteEvent::getOutstandingPackets, testing::SizeIs(1)),
+            &SocketObserverInterface::WriteEvent::getOutstandingPackets,
+            testing::SizeIs(1)),
         testing::Field(
-            &Observer::WriteEvent::writeCount, testing::Eq(writeCount)),
+            &SocketObserverInterface::WriteEvent::writeCount,
+            testing::Eq(writeCount)),
         testing::Field(
-            &Observer::WriteEvent::maybeCwndInBytes,
+            &SocketObserverInterface::WriteEvent::maybeCwndInBytes,
             testing::Eq(folly::Optional<uint64_t>(folly::none))),
         testing::Field(
-            &Observer::WriteEvent::maybeWritableBytes,
+            &SocketObserverInterface::WriteEvent::maybeWritableBytes,
             testing::Eq(folly::Optional<uint64_t>(folly::none))),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numPacketsWritten, testing::Eq(1)),
+            &SocketObserverInterface::PacketsWrittenEvent::numPacketsWritten,
+            testing::Eq(1)),
         testing::Field(
-            &Observer::PacketsWrittenEvent::numAckElicitingPacketsWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::
+                numAckElicitingPacketsWritten,
             testing::Eq(1)),
         testing::Field( // precise check in WillOnce()
-            &Observer::PacketsWrittenEvent::numBytesWritten,
+            &SocketObserverInterface::PacketsWrittenEvent::numBytesWritten,
             testing::Gt(strLength)));
     EXPECT_CALL(*observerWithNoEvents, packetsWritten(_, _)).Times(0);
     EXPECT_CALL(
@@ -2225,15 +2278,15 @@ TYPED_TEST(
 TYPED_TEST(
     QuicTypedTransportTestForObservers,
     AckEventsOutstandingPacketSentThenAckedNoAckDelay) {
-  MockObserver::Config configWithAcksEnabled;
+  MockLegacyObserver::Config configWithAcksEnabled;
   configWithAcksEnabled.acksProcessedEvents = true;
 
   auto transport = this->getTransport();
-  auto observerWithNoAcks = std::make_unique<NiceMock<MockObserver>>();
+  auto observerWithNoAcks = std::make_unique<NiceMock<MockLegacyObserver>>();
   auto observerWithAcks1 =
-      std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
   auto observerWithAcks2 =
-      std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
 
   EXPECT_CALL(*observerWithNoAcks, observerAttach(transport));
   transport->addObserver(observerWithNoAcks.get());
@@ -2298,15 +2351,15 @@ TYPED_TEST(
 TYPED_TEST(
     QuicTypedTransportTestForObservers,
     AckEventsOutstandingPacketSentThenAckedWithAckDelay) {
-  MockObserver::Config configWithAcksEnabled;
+  MockLegacyObserver::Config configWithAcksEnabled;
   configWithAcksEnabled.acksProcessedEvents = true;
 
   auto transport = this->getTransport();
-  auto observerWithNoAcks = std::make_unique<NiceMock<MockObserver>>();
+  auto observerWithNoAcks = std::make_unique<NiceMock<MockLegacyObserver>>();
   auto observerWithAcks1 =
-      std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
   auto observerWithAcks2 =
-      std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
 
   EXPECT_CALL(*observerWithNoAcks, observerAttach(transport));
   transport->addObserver(observerWithNoAcks.get());
@@ -2371,15 +2424,15 @@ TYPED_TEST(
 TYPED_TEST(
     QuicTypedTransportTestForObservers,
     AckEventsOutstandingPacketSentThenAckedWithAckDelayEqRtt) {
-  MockObserver::Config configWithAcksEnabled;
+  MockLegacyObserver::Config configWithAcksEnabled;
   configWithAcksEnabled.acksProcessedEvents = true;
 
   auto transport = this->getTransport();
-  auto observerWithNoAcks = std::make_unique<NiceMock<MockObserver>>();
+  auto observerWithNoAcks = std::make_unique<NiceMock<MockLegacyObserver>>();
   auto observerWithAcks1 =
-      std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
   auto observerWithAcks2 =
-      std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
 
   EXPECT_CALL(*observerWithNoAcks, observerAttach(transport));
   transport->addObserver(observerWithNoAcks.get());
@@ -2430,7 +2483,8 @@ TYPED_TEST(
           testing::AllOf(
               matcher,
               testing::Property(
-                  &quic::Observer::AcksProcessedEvent::getAckEvents,
+                  &quic::SocketObserverInterface::AcksProcessedEvent::
+                      getAckEvents,
                   testing::ElementsAre(testing::AllOf(testing::Field(
                       &quic::AckEvent::rttSampleNoAckDelay,
                       testing::AnyOf(
@@ -2442,7 +2496,8 @@ TYPED_TEST(
           testing::AllOf(
               matcher,
               testing::Property(
-                  &quic::Observer::AcksProcessedEvent::getAckEvents,
+                  &quic::SocketObserverInterface::AcksProcessedEvent::
+                      getAckEvents,
                   testing::ElementsAre(testing::AllOf(testing::Field(
                       &quic::AckEvent::rttSampleNoAckDelay,
                       testing::AnyOf(
@@ -2466,15 +2521,15 @@ TYPED_TEST(
 TYPED_TEST(
     QuicTypedTransportTestForObservers,
     AckEventsOutstandingPacketSentThenAckedWithTooLargeAckDelay) {
-  MockObserver::Config configWithAcksEnabled;
+  MockLegacyObserver::Config configWithAcksEnabled;
   configWithAcksEnabled.acksProcessedEvents = true;
 
   auto transport = this->getTransport();
-  auto observerWithNoAcks = std::make_unique<NiceMock<MockObserver>>();
+  auto observerWithNoAcks = std::make_unique<NiceMock<MockLegacyObserver>>();
   auto observerWithAcks1 =
-      std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
   auto observerWithAcks2 =
-      std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
 
   EXPECT_CALL(*observerWithNoAcks, observerAttach(transport));
   transport->addObserver(observerWithNoAcks.get());
@@ -2525,7 +2580,8 @@ TYPED_TEST(
           testing::AllOf(
               matcher,
               testing::Property(
-                  &quic::Observer::AcksProcessedEvent::getAckEvents,
+                  &quic::SocketObserverInterface::AcksProcessedEvent::
+                      getAckEvents,
                   testing::ElementsAre(testing::AllOf(testing::Field(
                       &quic::AckEvent::rttSampleNoAckDelay,
                       testing::Eq(folly::none))))))));
@@ -2536,7 +2592,8 @@ TYPED_TEST(
           testing::AllOf(
               matcher,
               testing::Property(
-                  &quic::Observer::AcksProcessedEvent::getAckEvents,
+                  &quic::SocketObserverInterface::AcksProcessedEvent::
+                      getAckEvents,
                   testing::ElementsAre(testing::AllOf(testing::Field(
                       &quic::AckEvent::rttSampleNoAckDelay,
                       testing::Eq(folly::none))))))));
@@ -2559,15 +2616,15 @@ TYPED_TEST(
 TYPED_TEST(
     QuicTypedTransportTestForObservers,
     AckEventsThreeOutstandingPacketsSentThenAllAckedAtOnce) {
-  MockObserver::Config configWithAcksEnabled;
+  MockLegacyObserver::Config configWithAcksEnabled;
   configWithAcksEnabled.acksProcessedEvents = true;
 
   auto transport = this->getTransport();
-  auto observerWithNoAcks = std::make_unique<NiceMock<MockObserver>>();
+  auto observerWithNoAcks = std::make_unique<NiceMock<MockLegacyObserver>>();
   auto observerWithAcks1 =
-      std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
   auto observerWithAcks2 =
-      std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
 
   EXPECT_CALL(*observerWithNoAcks, observerAttach(transport));
   transport->addObserver(observerWithNoAcks.get());
@@ -2645,15 +2702,15 @@ TYPED_TEST(
 TYPED_TEST(
     QuicTypedTransportTestForObservers,
     AckEventsThreeOutstandingPacketsSentAndAckedSequentially) {
-  MockObserver::Config configWithAcksEnabled;
+  MockLegacyObserver::Config configWithAcksEnabled;
   configWithAcksEnabled.acksProcessedEvents = true;
 
   auto transport = this->getTransport();
-  auto observerWithNoAcks = std::make_unique<NiceMock<MockObserver>>();
+  auto observerWithNoAcks = std::make_unique<NiceMock<MockLegacyObserver>>();
   auto observerWithAcks1 =
-      std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
   auto observerWithAcks2 =
-      std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
 
   EXPECT_CALL(*observerWithNoAcks, observerAttach(transport));
   transport->addObserver(observerWithNoAcks.get());
@@ -2797,15 +2854,15 @@ TYPED_TEST(
 TYPED_TEST(
     QuicTypedTransportTestForObservers,
     AckEventsThreeOutstandingPacketsSentThenAckedSequentially) {
-  MockObserver::Config configWithAcksEnabled;
+  MockLegacyObserver::Config configWithAcksEnabled;
   configWithAcksEnabled.acksProcessedEvents = true;
 
   auto transport = this->getTransport();
-  auto observerWithNoAcks = std::make_unique<NiceMock<MockObserver>>();
+  auto observerWithNoAcks = std::make_unique<NiceMock<MockLegacyObserver>>();
   auto observerWithAcks1 =
-      std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
   auto observerWithAcks2 =
-      std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
 
   EXPECT_CALL(*observerWithNoAcks, observerAttach(transport));
   transport->addObserver(observerWithNoAcks.get());
@@ -2958,7 +3015,7 @@ TYPED_TEST(
 TYPED_TEST(
     QuicTypedTransportTestForObservers,
     AckEventsThreeOutstandingPacketsSentThenFirstLastAckedSequentiallyThenSecondAcked) {
-  MockObserver::Config configWithAcksEnabled;
+  MockLegacyObserver::Config configWithAcksEnabled;
   configWithAcksEnabled.acksProcessedEvents = true;
 
   // prevent packets from being marked as lost
@@ -2968,11 +3025,11 @@ TYPED_TEST(
   this->getNonConstConn().transportSettings.timeReorderingThreshDivisor = 1;
 
   auto transport = this->getTransport();
-  auto observerWithNoAcks = std::make_unique<NiceMock<MockObserver>>();
+  auto observerWithNoAcks = std::make_unique<NiceMock<MockLegacyObserver>>();
   auto observerWithAcks1 =
-      std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
   auto observerWithAcks2 =
-      std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
 
   EXPECT_CALL(*observerWithNoAcks, observerAttach(transport));
   transport->addObserver(observerWithNoAcks.get());
@@ -3123,7 +3180,7 @@ TYPED_TEST(
 TYPED_TEST(
     QuicTypedTransportTestForObservers,
     AckEventsThreeOutstandingPacketsSentThenFirstLastAckedAtOnceThenSecondAcked) {
-  MockObserver::Config configWithAcksEnabled;
+  MockLegacyObserver::Config configWithAcksEnabled;
   configWithAcksEnabled.acksProcessedEvents = true;
 
   // prevent packets from being marked as lost
@@ -3133,11 +3190,11 @@ TYPED_TEST(
   this->getNonConstConn().transportSettings.timeReorderingThreshDivisor = 1;
 
   auto transport = this->getTransport();
-  auto observerWithNoAcks = std::make_unique<NiceMock<MockObserver>>();
+  auto observerWithNoAcks = std::make_unique<NiceMock<MockLegacyObserver>>();
   auto observerWithAcks1 =
-      std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
   auto observerWithAcks2 =
-      std::make_unique<NiceMock<MockObserver>>(configWithAcksEnabled);
+      std::make_unique<NiceMock<MockLegacyObserver>>(configWithAcksEnabled);
 
   EXPECT_CALL(*observerWithNoAcks, observerAttach(transport));
   transport->addObserver(observerWithNoAcks.get());

quic/common/test/MonitoredObjectTest.cpp

@@ -15,7 +15,7 @@ using namespace std;
 using namespace quic;
 using namespace ::testing;
 
-class MockObserver {
+class MockObjectObserver {
  public:
   MOCK_METHOD(void, accessed, (const string&));
 };
@@ -23,9 +23,9 @@ class MockObserver {
 TEST(MonitoredObjectTest, TestObserverCalled) {
   InSequence s;
   string x = "abc";
-  MockObserver observer;
+  MockObjectObserver observer;
   auto accessFn =
-      std::bind(&MockObserver::accessed, &observer, placeholders::_1);
+      std::bind(&MockObjectObserver::accessed, &observer, placeholders::_1);
   MonitoredObject<string> mo(x, accessFn);
   EXPECT_CALL(observer, accessed(x)).Times(1);
   EXPECT_EQ(x, mo->c_str());

quic/d6d/QuicD6DStateFunctions.cpp

@@ -26,7 +26,7 @@ static TimePoint reportUpperBound(QuicConnectionStateBase& conn) {
 
   QUIC_STATS(conn.statsCallback, onConnectionPMTUUpperBoundDetected);
   if (conn.observers->size() > 0) {
-    Observer::PMTUUpperBoundEvent upperBoundEvent(
+    SocketObserverInterface::PMTUUpperBoundEvent upperBoundEvent(
         now,
         std::chrono::duration_cast<std::chrono::microseconds>(
             now - d6d.meta.timeLastNonSearchState),
@@ -58,7 +58,7 @@ static TimePoint reportBlackhole(
   auto& d6d = conn.d6d;
   const auto now = Clock::now();
   if (conn.observers->size() > 0) {
-    Observer::PMTUBlackholeEvent blackholeEvent(
+    SocketObserverInterface::PMTUBlackholeEvent blackholeEvent(
         now,
         std::chrono::duration_cast<std::chrono::microseconds>(
             now - d6d.meta.timeLastNonSearchState),

quic/d6d/test/QuicD6DStateFunctionsTest.cpp

@@ -189,11 +189,11 @@ TEST_F(QuicD6DStateFunctionsTest, D6DProbeAckedInBase) {
   const uint16_t expectPMTU = 1400;
   auto& d6d = conn.d6d;
   auto now = Clock::now();
-  Observer::Config config = {};
+  LegacyObserver::Config config = {};
   config.pmtuEvents = true;
-  auto mockObserver = std::make_unique<StrictMock<MockObserver>>(config);
+  auto observer = std::make_unique<StrictMock<MockLegacyObserver>>(config);
   auto observers = std::make_shared<ObserverVec>();
-  observers->emplace_back(mockObserver.get());
+  observers->emplace_back(observer.get());
   conn.observers = observers;
   d6d.state = D6DMachineState::BASE;
   d6d.outstandingProbes = 1;
@@ -220,7 +220,7 @@ TEST_F(QuicD6DStateFunctionsTest, D6DProbeAckedInBase) {
   EXPECT_CALL(*mockRaiser, raiseProbeSize(d6d.currentProbeSize))
       .Times(1)
       .WillOnce(Return(expectPMTU));
-  EXPECT_CALL(*mockObserver, pmtuUpperBoundDetected(_, _)).Times(0);
+  EXPECT_CALL(*observer, pmtuUpperBoundDetected(_, _)).Times(0);
   onD6DLastProbeAcked(conn);
   for (auto& callback : conn.pendingCallbacks) {
     callback(nullptr);
@@ -237,11 +237,11 @@ TEST_F(QuicD6DStateFunctionsTest, D6DProbeAckedInSearchingOne) {
   const uint16_t expectPMTU = 1400;
   auto& d6d = conn.d6d;
   auto now = Clock::now();
-  Observer::Config config = {};
+  LegacyObserver::Config config = {};
   config.pmtuEvents = true;
-  auto mockObserver = std::make_unique<StrictMock<MockObserver>>(config);
+  auto observer = std::make_unique<StrictMock<MockLegacyObserver>>(config);
   auto observers = std::make_shared<ObserverVec>();
-  observers->emplace_back(mockObserver.get());
+  observers->emplace_back(observer.get());
   conn.observers = observers;
   d6d.state = D6DMachineState::SEARCHING;
   d6d.outstandingProbes = 1;
@@ -269,7 +269,7 @@ TEST_F(QuicD6DStateFunctionsTest, D6DProbeAckedInSearchingOne) {
   EXPECT_CALL(*mockRaiser, raiseProbeSize(d6d.currentProbeSize))
       .Times(1)
       .WillOnce(Return(expectPMTU));
-  EXPECT_CALL(*mockObserver, pmtuUpperBoundDetected(_, _)).Times(0);
+  EXPECT_CALL(*observer, pmtuUpperBoundDetected(_, _)).Times(0);
   onD6DLastProbeAcked(conn);
   for (auto& callback : conn.pendingCallbacks) {
     callback(nullptr);
@@ -286,11 +286,11 @@ TEST_F(QuicD6DStateFunctionsTest, D6DProbeAckedInSearchingMax) {
   const uint16_t oversize = 1500;
   auto& d6d = conn.d6d;
   auto now = Clock::now();
-  Observer::Config config = {};
+  LegacyObserver::Config config = {};
   config.pmtuEvents = true;
-  auto mockObserver = std::make_unique<StrictMock<MockObserver>>(config);
+  auto observer = std::make_unique<StrictMock<MockLegacyObserver>>(config);
   auto observers = std::make_shared<ObserverVec>();
-  observers->emplace_back(mockObserver.get());
+  observers->emplace_back(observer.get());
   conn.observers = observers;
   d6d.state = D6DMachineState::SEARCHING;
   d6d.outstandingProbes = 3;
@@ -319,17 +319,19 @@ TEST_F(QuicD6DStateFunctionsTest, D6DProbeAckedInSearchingMax) {
   EXPECT_CALL(*mockRaiser, raiseProbeSize(d6d.currentProbeSize))
       .Times(1)
       .WillOnce(Return(oversize));
-  EXPECT_CALL(*mockObserver, pmtuUpperBoundDetected(_, _))
+  EXPECT_CALL(*observer, pmtuUpperBoundDetected(_, _))
       .Times(1)
-      .WillOnce(Invoke([&](QuicSocket* /* qSocket */,
-                           const Observer::PMTUUpperBoundEvent& event) {
-        EXPECT_LT(now, event.upperBoundTime);
-        EXPECT_LT(0us, event.timeSinceLastNonSearchState);
-        EXPECT_EQ(D6DMachineState::BASE, event.lastNonSearchState);
-        EXPECT_EQ(1450, event.upperBoundPMTU);
-        EXPECT_EQ(10, event.cumulativeProbesSent);
-        EXPECT_EQ(ProbeSizeRaiserType::ConstantStep, event.probeSizeRaiserType);
-      }));
+      .WillOnce(Invoke(
+          [&](QuicSocket* /* qSocket */,
+              const SocketObserverInterface::PMTUUpperBoundEvent& event) {
+            EXPECT_LT(now, event.upperBoundTime);
+            EXPECT_LT(0us, event.timeSinceLastNonSearchState);
+            EXPECT_EQ(D6DMachineState::BASE, event.lastNonSearchState);
+            EXPECT_EQ(1450, event.upperBoundPMTU);
+            EXPECT_EQ(10, event.cumulativeProbesSent);
+            EXPECT_EQ(
+                ProbeSizeRaiserType::ConstantStep, event.probeSizeRaiserType);
+          }));
   onD6DLastProbeAcked(conn);
   for (auto& callback : conn.pendingCallbacks) {
     callback(nullptr);
@@ -345,11 +347,11 @@ TEST_F(QuicD6DStateFunctionsTest, D6DProbeAckedInError) {
   QuicConnectionStateBase conn(QuicNodeType::Server);
   auto& d6d = conn.d6d;
   auto now = Clock::now();
-  Observer::Config config = {};
+  LegacyObserver::Config config = {};
   config.pmtuEvents = true;
-  auto mockObserver = std::make_unique<StrictMock<MockObserver>>(config);
+  auto observer = std::make_unique<StrictMock<MockLegacyObserver>>(config);
   auto observers = std::make_shared<ObserverVec>();
-  observers->emplace_back(mockObserver.get());
+  observers->emplace_back(observer.get());
   conn.observers = observers;
   d6d.state = D6DMachineState::ERROR;
   d6d.outstandingProbes = 3;
@@ -377,7 +379,7 @@ TEST_F(QuicD6DStateFunctionsTest, D6DProbeAckedInError) {
   EXPECT_CALL(*mockRaiser, raiseProbeSize(d6d.currentProbeSize))
       .Times(1)
       .WillOnce(Return(1300)); // Won't be used
-  EXPECT_CALL(*mockObserver, pmtuUpperBoundDetected(_, _)).Times(0);
+  EXPECT_CALL(*observer, pmtuUpperBoundDetected(_, _)).Times(0);
   onD6DLastProbeAcked(conn);
   for (auto& callback : conn.pendingCallbacks) {
     callback(nullptr);
@@ -393,11 +395,11 @@ TEST_F(QuicD6DStateFunctionsTest, BlackholeInSearching) {
   QuicConnectionStateBase conn(QuicNodeType::Server);
   auto& d6d = conn.d6d;
   auto now = Clock::now();
-  Observer::Config config = {};
+  LegacyObserver::Config config = {};
   config.pmtuEvents = true;
-  auto mockObserver = std::make_unique<StrictMock<MockObserver>>(config);
+  auto observer = std::make_unique<StrictMock<MockLegacyObserver>>(config);
   auto observers = std::make_shared<ObserverVec>();
-  observers->emplace_back(mockObserver.get());
+  observers->emplace_back(observer.get());
   conn.observers = observers;
   d6d.state = D6DMachineState::SEARCHING;
   d6d.outstandingProbes = 2;
@@ -439,20 +441,21 @@ TEST_F(QuicD6DStateFunctionsTest, BlackholeInSearching) {
       std::chrono::microseconds(kDefaultD6DBlackholeDetectionWindow).count(),
       1); // Threshold of 1 will cause window to be set to 0
 
-  EXPECT_CALL(*mockObserver, pmtuBlackholeDetected(_, _))
+  EXPECT_CALL(*observer, pmtuBlackholeDetected(_, _))
       .Times(1)
-      .WillOnce(Invoke([&](QuicSocket* /* qSocket */,
-                           const Observer::PMTUBlackholeEvent& event) {
-        EXPECT_LE(d6d.meta.timeLastNonSearchState, event.blackholeTime);
-        EXPECT_EQ(D6DMachineState::BASE, event.lastNonSearchState);
-        EXPECT_EQ(D6DMachineState::SEARCHING, event.currentState);
-        EXPECT_EQ(d6d.basePMTU + 20, event.udpSendPacketLen);
-        EXPECT_EQ(d6d.basePMTU + 30, event.lastProbeSize);
-        EXPECT_EQ(0, event.blackholeDetectionWindow);
-        EXPECT_EQ(1, event.blackholeDetectionThreshold);
-        EXPECT_EQ(
-            d6d.basePMTU + 20, event.triggeringPacketMetadata.encodedSize);
-      }));
+      .WillOnce(
+          Invoke([&](QuicSocket* /* qSocket */,
+                     const SocketObserverInterface::PMTUBlackholeEvent& event) {
+            EXPECT_LE(d6d.meta.timeLastNonSearchState, event.blackholeTime);
+            EXPECT_EQ(D6DMachineState::BASE, event.lastNonSearchState);
+            EXPECT_EQ(D6DMachineState::SEARCHING, event.currentState);
+            EXPECT_EQ(d6d.basePMTU + 20, event.udpSendPacketLen);
+            EXPECT_EQ(d6d.basePMTU + 30, event.lastProbeSize);
+            EXPECT_EQ(0, event.blackholeDetectionWindow);
+            EXPECT_EQ(1, event.blackholeDetectionThreshold);
+            EXPECT_EQ(
+                d6d.basePMTU + 20, event.triggeringPacketMetadata.encodedSize);
+          }));
 
   detectPMTUBlackhole(conn, lostPacket);
   for (auto& callback : conn.pendingCallbacks) {
@@ -470,11 +473,11 @@ TEST_F(QuicD6DStateFunctionsTest, BlackholeInSearchComplete) {
   QuicConnectionStateBase conn(QuicNodeType::Server);
   auto& d6d = conn.d6d;
   auto now = Clock::now();
-  Observer::Config config = {};
+  LegacyObserver::Config config = {};
   config.pmtuEvents = true;
-  auto mockObserver = std::make_unique<StrictMock<MockObserver>>(config);
+  auto observer = std::make_unique<StrictMock<MockLegacyObserver>>(config);
   auto observers = std::make_shared<ObserverVec>();
-  observers->emplace_back(mockObserver.get());
+  observers->emplace_back(observer.get());
   conn.observers = observers;
   d6d.state = D6DMachineState::SEARCH_COMPLETE;
   conn.udpSendPacketLen = d6d.basePMTU + 20;
@@ -516,20 +519,21 @@ TEST_F(QuicD6DStateFunctionsTest, BlackholeInSearchComplete) {
       std::chrono::microseconds(kDefaultD6DBlackholeDetectionWindow).count(),
       1); // Threshold of 1 will cause window to be set to 0
 
-  EXPECT_CALL(*mockObserver, pmtuBlackholeDetected(_, _))
+  EXPECT_CALL(*observer, pmtuBlackholeDetected(_, _))
       .Times(1)
-      .WillOnce(Invoke([&](QuicSocket* /* qSocket */,
-                           const Observer::PMTUBlackholeEvent& event) {
-        EXPECT_EQ(d6d.meta.timeLastNonSearchState, event.blackholeTime);
-        EXPECT_EQ(D6DMachineState::BASE, event.lastNonSearchState);
-        EXPECT_EQ(D6DMachineState::SEARCH_COMPLETE, event.currentState);
-        EXPECT_EQ(d6d.basePMTU + 20, event.udpSendPacketLen);
-        EXPECT_EQ(d6d.basePMTU + 20, event.lastProbeSize);
-        EXPECT_EQ(0, event.blackholeDetectionWindow);
-        EXPECT_EQ(1, event.blackholeDetectionThreshold);
-        EXPECT_EQ(
-            d6d.basePMTU + 20, event.triggeringPacketMetadata.encodedSize);
-      }));
+      .WillOnce(
+          Invoke([&](QuicSocket* /* qSocket */,
+                     const SocketObserverInterface::PMTUBlackholeEvent& event) {
+            EXPECT_EQ(d6d.meta.timeLastNonSearchState, event.blackholeTime);
+            EXPECT_EQ(D6DMachineState::BASE, event.lastNonSearchState);
+            EXPECT_EQ(D6DMachineState::SEARCH_COMPLETE, event.currentState);
+            EXPECT_EQ(d6d.basePMTU + 20, event.udpSendPacketLen);
+            EXPECT_EQ(d6d.basePMTU + 20, event.lastProbeSize);
+            EXPECT_EQ(0, event.blackholeDetectionWindow);
+            EXPECT_EQ(1, event.blackholeDetectionThreshold);
+            EXPECT_EQ(
+                d6d.basePMTU + 20, event.triggeringPacketMetadata.encodedSize);
+          }));
 
   detectPMTUBlackhole(conn, lostPacket);
   for (auto& callback : conn.pendingCallbacks) {
@@ -547,11 +551,11 @@ TEST_F(QuicD6DStateFunctionsTest, ReachMaxPMTU) {
   QuicConnectionStateBase conn(QuicNodeType::Server);
   auto& d6d = conn.d6d;
   auto now = Clock::now();
-  Observer::Config config = {};
+  LegacyObserver::Config config = {};
   config.pmtuEvents = true;
-  auto mockObserver = std::make_unique<StrictMock<MockObserver>>(config);
+  auto observer = std::make_unique<StrictMock<MockLegacyObserver>>(config);
   auto observers = std::make_shared<ObserverVec>();
-  observers->emplace_back(mockObserver.get());
+  observers->emplace_back(observer.get());
   conn.observers = observers;
   d6d.state = D6DMachineState::SEARCHING;
   d6d.maxPMTU = 1452;

quic/loss/QuicLossFunctions.h

@@ -213,7 +213,7 @@ folly::Optional<CongestionController::LossEvent> detectLossPackets(
            << " delayUntilLost=" << delayUntilLost.count() << "us"
            << " " << conn;
   CongestionController::LossEvent lossEvent(lossTime);
-  folly::Optional<Observer::LossEvent> observerLossEvent;
+  folly::Optional<SocketObserverInterface::LossEvent> observerLossEvent;
   if (!conn.observers->empty()) {
     observerLossEvent.emplace(lossTime);
   }

quic/loss/test/QuicLossFunctionsTest.cpp

@@ -165,7 +165,7 @@ class QuicLossFunctionsTest : public TestWithParam<PacketNumberSpace> {
       PacketNum packetNum,
       bool lossByReorder,
       bool lossByTimeout) {
-    return MockObserver::getLossPacketMatcher(
+    return MockLegacyObserver::getLossPacketMatcher(
         packetNum, lossByReorder, lossByTimeout);
   }
 };
@@ -2021,9 +2021,9 @@ TEST_F(QuicLossFunctionsTest, PersistentCongestionNoPTO) {
 
 TEST_F(QuicLossFunctionsTest, TestReorderLossObserverCallback) {
   auto observers = std::make_shared<ObserverVec>();
-  Observer::Config config = {};
+  LegacyObserver::Config config = {};
   config.lossEvents = true;
-  auto ib = MockObserver(config);
+  auto ib = MockLegacyObserver(config);
   auto conn = createConn();
   // Register 1 observer
   observers->emplace_back(&ib);
@@ -2074,7 +2074,7 @@ TEST_F(QuicLossFunctionsTest, TestReorderLossObserverCallback) {
       packetLossDetected(
           nullptr,
           Field(
-              &Observer::LossEvent::lostPackets,
+              &SocketObserverInterface::LossEvent::lostPackets,
               UnorderedElementsAre(
                   getLossPacketMatcher(1, true, false),
                   getLossPacketMatcher(2, true, false),
@@ -2088,9 +2088,9 @@ TEST_F(QuicLossFunctionsTest, TestReorderLossObserverCallback) {
 
 TEST_F(QuicLossFunctionsTest, TestTimeoutLossObserverCallback) {
   auto observers = std::make_shared<ObserverVec>();
-  Observer::Config config = {};
+  LegacyObserver::Config config = {};
   config.lossEvents = true;
-  auto ib = MockObserver(config);
+  auto ib = MockLegacyObserver(config);
   auto conn = createConn();
   // Register 1 observer
   observers->emplace_back(&ib);
@@ -2142,7 +2142,7 @@ TEST_F(QuicLossFunctionsTest, TestTimeoutLossObserverCallback) {
       packetLossDetected(
           nullptr,
           Field(
-              &Observer::LossEvent::lostPackets,
+              &SocketObserverInterface::LossEvent::lostPackets,
               UnorderedElementsAre(
                   getLossPacketMatcher(1, false, true),
                   getLossPacketMatcher(2, false, true),
@@ -2160,9 +2160,9 @@ TEST_F(QuicLossFunctionsTest, TestTimeoutLossObserverCallback) {
 
 TEST_F(QuicLossFunctionsTest, TestTimeoutAndReorderLossObserverCallback) {
   auto observers = std::make_shared<ObserverVec>();
-  Observer::Config config = {};
+  LegacyObserver::Config config = {};
   config.lossEvents = true;
-  auto ib = MockObserver(config);
+  auto ib = MockLegacyObserver(config);
   auto conn = createConn();
   // Register 1 observer
   observers->emplace_back(&ib);
@@ -2216,7 +2216,7 @@ TEST_F(QuicLossFunctionsTest, TestTimeoutAndReorderLossObserverCallback) {
       packetLossDetected(
           nullptr,
           Field(
-              &Observer::LossEvent::lostPackets,
+              &SocketObserverInterface::LossEvent::lostPackets,
               UnorderedElementsAre(
                   getLossPacketMatcher(1, true, true),
                   getLossPacketMatcher(2, true, true),

quic/server/test/QuicServerTransportTest.cpp

@@ -4189,20 +4189,20 @@ TEST_P(
 }
 
 TEST_P(QuicServerTransportHandshakeTest, TestD6DStartCallback) {
-  Observer::Config config = {};
+  LegacyObserver::Config config = {};
   config.pmtuEvents = true;
-  auto mockObserver = std::make_unique<MockObserver>(config);
-  server->addObserver(mockObserver.get());
+  auto observer = std::make_unique<MockLegacyObserver>(config);
+  server->addObserver(observer.get());
   // Set oneRttReader so that maybeStartD6DPriobing passes its check
   auto codec = std::make_unique<QuicReadCodec>(QuicNodeType::Server);
   codec->setOneRttReadCipher(createNoOpAead());
   server->getNonConstConn().readCodec = std::move(codec);
   // And the state too
   server->getNonConstConn().d6d.state = D6DMachineState::BASE;
-  EXPECT_CALL(*mockObserver, pmtuProbingStarted(_)).Times(1);
+  EXPECT_CALL(*observer, pmtuProbingStarted(_)).Times(1);
   // CHLO should be enough to trigger probing
   recvClientHello();
-  server->removeObserver(mockObserver.get());
+  server->removeObserver(observer.get());
 }
 
 TEST_F(QuicUnencryptedServerTransportTest, DuplicateOneRttWriteCipher) {

quic/state/AckHandlers.cpp

@@ -73,7 +73,7 @@ AckEvent processAckFrame(
   uint64_t dsrPacketsAcked = 0;
   folly::Optional<decltype(conn.lossState.lastAckedPacketSentTime)>
       lastAckedPacketSentTime;
-  folly::Optional<Observer::SpuriousLossEvent> spuriousLossEvent;
+  folly::Optional<LegacyObserver::SpuriousLossEvent> spuriousLossEvent;
   // Used for debug only.
   const auto originalPacketCount = conn.outstandings.packetCount;
   if (conn.observers->size() > 0) {
@@ -198,7 +198,7 @@ AckEvent processAckFrame(
             ackReceiveTimeOrNow - rPacketIt->metadata.time);
         if (rttSample != rttSample.zero()) {
           // notify observers
-          const Observer::PacketRTT packetRTT(
+          const SocketObserverInterface::PacketRTT packetRTT(
               ackReceiveTimeOrNow, rttSample, frame.ackDelay, *rPacketIt);
           for (const auto& observer : *(conn.observers)) {
             conn.pendingCallbacks.emplace_back(

quic/state/test/AckHandlersTest.cpp

@@ -2322,9 +2322,9 @@ TEST_P(AckHandlersTest, TestRTTPacketObserverCallback) {
   conn.congestionController = std::move(mockCongestionController);
 
   // Register 1 observer
-  Observer::Config config = {};
+  LegacyObserver::Config config = {};
   config.rttSamples = true;
-  auto ib = MockObserver(config);
+  auto ib = MockLegacyObserver(config);
 
   auto observers = std::make_shared<ObserverVec>();
   observers->emplace_back(&ib);
@@ -2420,11 +2420,16 @@ TEST_P(AckHandlersTest, TestRTTPacketObserverCallback) {
         rttSampleGenerated(
             nullptr,
             AllOf(
-                Field(&Observer::PacketRTT::rcvTime, ackData.ackTime),
-                Field(&Observer::PacketRTT::rttSample, rttSample),
-                Field(&Observer::PacketRTT::ackDelay, ackData.ackDelay),
                 Field(
-                    &Observer::PacketRTT::metadata,
+                    &SocketObserverInterface::PacketRTT::rcvTime,
+                    ackData.ackTime),
+                Field(
+                    &SocketObserverInterface::PacketRTT::rttSample, rttSample),
+                Field(
+                    &SocketObserverInterface::PacketRTT::ackDelay,
+                    ackData.ackDelay),
+                Field(
+                    &SocketObserverInterface::PacketRTT::metadata,
                     Field(
                         &quic::OutstandingPacketMetadata::inflightBytes,
                         ackData.endSeq + 1)))));
@@ -2442,10 +2447,10 @@ TEST_P(AckHandlersTest, TestSpuriousObserverReorder) {
   conn.congestionController = std::move(mockCongestionController);
 
   // Register 1 observer
-  Observer::Config config = {};
+  LegacyObserver::Config config = {};
   config.spuriousLossEvents = true;
   config.lossEvents = true;
-  auto ib = MockObserver(config);
+  auto ib = MockLegacyObserver(config);
 
   auto observers = std::make_shared<ObserverVec>();
   observers->emplace_back(&ib);
@@ -2480,11 +2485,11 @@ TEST_P(AckHandlersTest, TestSpuriousObserverReorder) {
       packetLossDetected(
           nullptr,
           Field(
-              &Observer::LossEvent::lostPackets,
+              &SocketObserverInterface::LossEvent::lostPackets,
               UnorderedElementsAre(
-                  MockObserver::getLossPacketMatcher(0, true, false),
-                  MockObserver::getLossPacketMatcher(1, true, false),
-                  MockObserver::getLossPacketMatcher(2, true, false)))))
+                  MockLegacyObserver::getLossPacketMatcher(0, true, false),
+                  MockLegacyObserver::getLossPacketMatcher(1, true, false),
+                  MockLegacyObserver::getLossPacketMatcher(2, true, false)))))
       .Times(1);
 
   // Here we receive the spurious loss packets in a late ack
@@ -2510,11 +2515,11 @@ TEST_P(AckHandlersTest, TestSpuriousObserverReorder) {
       spuriousLossDetected(
           nullptr,
           Field(
-              &Observer::SpuriousLossEvent::spuriousPackets,
+              &SocketObserverInterface::SpuriousLossEvent::spuriousPackets,
               UnorderedElementsAre(
-                  MockObserver::getLossPacketMatcher(0, true, false),
-                  MockObserver::getLossPacketMatcher(1, true, false),
-                  MockObserver::getLossPacketMatcher(2, true, false)))))
+                  MockLegacyObserver::getLossPacketMatcher(0, true, false),
+                  MockLegacyObserver::getLossPacketMatcher(1, true, false),
+                  MockLegacyObserver::getLossPacketMatcher(2, true, false)))))
       .Times(1);
 
   for (auto& callback : conn.pendingCallbacks) {
@@ -2529,10 +2534,10 @@ TEST_P(AckHandlersTest, TestSpuriousObserverTimeout) {
   conn.congestionController = std::move(mockCongestionController);
 
   // Register 1 observer
-  Observer::Config config = {};
+  LegacyObserver::Config config = {};
   config.spuriousLossEvents = true;
   config.lossEvents = true;
-  auto ib = MockObserver(config);
+  auto ib = MockLegacyObserver(config);
 
   auto observers = std::make_shared<ObserverVec>();
   observers->emplace_back(&ib);
@@ -2567,13 +2572,13 @@ TEST_P(AckHandlersTest, TestSpuriousObserverTimeout) {
       packetLossDetected(
           nullptr,
           Field(
-              &Observer::LossEvent::lostPackets,
+              &SocketObserverInterface::LossEvent::lostPackets,
               UnorderedElementsAre(
-                  MockObserver::getLossPacketMatcher(5, false, true),
-                  MockObserver::getLossPacketMatcher(6, false, true),
-                  MockObserver::getLossPacketMatcher(7, false, true),
-                  MockObserver::getLossPacketMatcher(8, false, true),
-                  MockObserver::getLossPacketMatcher(9, false, true)))))
+                  MockLegacyObserver::getLossPacketMatcher(5, false, true),
+                  MockLegacyObserver::getLossPacketMatcher(6, false, true),
+                  MockLegacyObserver::getLossPacketMatcher(7, false, true),
+                  MockLegacyObserver::getLossPacketMatcher(8, false, true),
+                  MockLegacyObserver::getLossPacketMatcher(9, false, true)))))
       .Times(1);
 
   // Here we receive the spurious loss packets in a late ack
@@ -2599,13 +2604,13 @@ TEST_P(AckHandlersTest, TestSpuriousObserverTimeout) {
       spuriousLossDetected(
           nullptr,
           Field(
-              &Observer::SpuriousLossEvent::spuriousPackets,
+              &SocketObserverInterface::SpuriousLossEvent::spuriousPackets,
               UnorderedElementsAre(
-                  MockObserver::getLossPacketMatcher(5, false, true),
-                  MockObserver::getLossPacketMatcher(6, false, true),
-                  MockObserver::getLossPacketMatcher(7, false, true),
-                  MockObserver::getLossPacketMatcher(8, false, true),
-                  MockObserver::getLossPacketMatcher(9, false, true)))))
+                  MockLegacyObserver::getLossPacketMatcher(5, false, true),
+                  MockLegacyObserver::getLossPacketMatcher(6, false, true),
+                  MockLegacyObserver::getLossPacketMatcher(7, false, true),
+                  MockLegacyObserver::getLossPacketMatcher(8, false, true),
+                  MockLegacyObserver::getLossPacketMatcher(9, false, true)))))
       .Times(1);
 
   for (auto& callback : conn.pendingCallbacks) {

quic/tools/tperf/tperf.cpp

@@ -139,12 +139,14 @@ ProbeSizeRaiserType parseRaiserType(uint32_t type) {
   }
 }
 
-class TPerfObserver : public Observer {
+class TPerfObserver : public LegacyObserver {
  public:
-  TPerfObserver(const Observer::Config& config) : Observer(config) {}
+  explicit TPerfObserver(const LegacyObserver::Config& config)
+      : LegacyObserver(config) {}
   void appRateLimited(
       QuicSocket* /* socket */,
-      const quic::Observer::AppLimitedEvent& /* appLimitedEvent */) override {
+      const quic::SocketObserverInterface::
+          AppLimitedEvent& /* appLimitedEvent */) override {
     if (FLAGS_log_app_rate_limited) {
       LOG(INFO) << "appRateLimited detected";
     }
@@ -200,7 +202,7 @@ class TPerfAcceptObserver : public AcceptObserver {
   TPerfAcceptObserver() {
     // Create an observer config, only enabling events we are interested in
     // receiving.
-    Observer::Config config = {};
+    LegacyObserver::Config config = {};
     config.appRateLimitedEvents = true;
     config.pmtuEvents = true;
     config.rttSamples = true;