diff --git a/quiche/quic/core/quic_connection.cc b/quiche/quic/core/quic_connection.cc
index 867caf6..80de256 100644
--- a/quiche/quic/core/quic_connection.cc
+++ b/quiche/quic/core/quic_connection.cc
@@ -4101,20 +4101,8 @@
     return;
   }
 
-  visitor_->CreateContextForMultiPortPath(
-      [this](std::unique_ptr<QuicPathValidationContext> path_context) {
-        if (!path_context) {
-          return;
-        }
-        auto multi_port_validation_result_delegate =
-            std::make_unique<MultiPortPathValidationResultDelegate>(this);
-        multi_port_probing_alarm_->Cancel();
-        multi_port_path_context_ = nullptr;
-        multi_port_stats_->num_multi_port_paths_created++;
-        ValidatePath(std::move(path_context),
-                     std::move(multi_port_validation_result_delegate),
-                     PathValidationReason::kMultiPort);
-      });
+  auto context_observer = std::make_unique<ContextObserver>(this);
+  visitor_->CreateContextForMultiPortPath(std::move(context_observer));
 }
 
 void QuicConnection::SendOrQueuePacket(SerializedPacket packet) {
@@ -7274,6 +7262,21 @@
       PathValidationReason::kMultiPort);
 }
 
+void QuicConnection::ContextObserver::OnMultiPortPathContextAvailable(
+    std::unique_ptr<QuicPathValidationContext> path_context) {
+  if (!path_context) {
+    return;
+  }
+  auto multi_port_validation_result_delegate =
+      std::make_unique<MultiPortPathValidationResultDelegate>(connection_);
+  connection_->multi_port_probing_alarm_->Cancel();
+  connection_->multi_port_path_context_ = nullptr;
+  connection_->multi_port_stats_->num_multi_port_paths_created++;
+  connection_->ValidatePath(std::move(path_context),
+                            std::move(multi_port_validation_result_delegate),
+                            PathValidationReason::kMultiPort);
+}
+
 QuicConnection::MultiPortPathValidationResultDelegate::
     MultiPortPathValidationResultDelegate(QuicConnection* connection)
     : connection_(connection) {
@@ -7304,8 +7307,7 @@
       peer_address_alternative_path_(
           connection_->alternative_path_.peer_address),
       active_effective_peer_migration_type_(
-          connection_->active_effective_peer_migration_type_) {
-}
+          connection_->active_effective_peer_migration_type_) {}
 
 void QuicConnection::ReversePathValidationResultDelegate::
     OnPathValidationSuccess(std::unique_ptr<QuicPathValidationContext> context,
diff --git a/quiche/quic/core/quic_connection.h b/quiche/quic/core/quic_connection.h
index 94d60eb..a5dfe53 100644
--- a/quiche/quic/core/quic_connection.h
+++ b/quiche/quic/core/quic_connection.h
@@ -73,6 +73,16 @@
 class QuicConnectionPeer;
 }  // namespace test
 
+// Class that receives callbacks from the connection when the path context is
+// available.
+class QUIC_EXPORT_PRIVATE MultiPortPathContextObserver {
+ public:
+  virtual void OnMultiPortPathContextAvailable(
+      std::unique_ptr<QuicPathValidationContext>) = 0;
+
+  virtual ~MultiPortPathContextObserver() = default;
+};
+
 // Class that receives callbacks from the connection when frames are received
 // and when other interesting events happen.
 class QUIC_EXPORT_PRIVATE QuicConnectionVisitorInterface {
@@ -237,14 +247,14 @@
   // When bandwidth update alarms.
   virtual void OnBandwidthUpdateTimeout() = 0;
 
-  // Runs |create_context| with context needed for the connection to probe on
-  // the alternative path. The callback must be called exactly once. May run
-  // |create_context| synchronously or asynchronously. If |create_context| is
+  // Runs OnMultiPortPathContextAvailable() from |context_observer| with context
+  // needed for the connection to probe on the alternative path. The callback
+  // must be called exactly once. May run OnMultiPortPathContextAvailable()
+  // synchronously or asynchronously. If OnMultiPortPathContextAvailable() is
   // run asynchronously, it must be called on the same thread as QuicConnection
   // is not thread safe.
   virtual void CreateContextForMultiPortPath(
-      std::function<void(std::unique_ptr<QuicPathValidationContext>)>
-          create_context) = 0;
+      std::unique_ptr<MultiPortPathContextObserver> context_observer) = 0;
 
   // Migrate to the multi-port path which is identified by |context|.
   virtual void MigrateToMultiPortPath(
@@ -646,9 +656,7 @@
 
   // Mark version negotiated for this connection. Once called, the connection
   // will ignore received version negotiation packets.
-  void SetVersionNegotiated() {
-    version_negotiated_ = true;
-  }
+  void SetVersionNegotiated() { version_negotiated_ = true; }
 
   // From QuicFramerVisitorInterface
   void OnError(QuicFramer* framer) override;
@@ -1575,6 +1583,18 @@
     AddressChangeType active_effective_peer_migration_type_;
   };
 
+  class ContextObserver final : public MultiPortPathContextObserver {
+   public:
+    explicit ContextObserver(QuicConnection* connection)
+        : connection_(connection) {}
+
+    void OnMultiPortPathContextAvailable(
+        std::unique_ptr<QuicPathValidationContext> path_context) override;
+
+   private:
+    QuicConnection* connection_;
+  };
+
   // Keeps an ongoing alternative path. The connection will not migrate upon
   // validation success.
   class MultiPortPathValidationResultDelegate
diff --git a/quiche/quic/core/quic_connection_test.cc b/quiche/quic/core/quic_connection_test.cc
index 6a0e9d0..88a9fd4 100644
--- a/quiche/quic/core/quic_connection_test.cc
+++ b/quiche/quic/core/quic_connection_test.cc
@@ -13383,9 +13383,10 @@
   frame.retire_prior_to = 0u;
   frame.sequence_number = 1u;
   EXPECT_CALL(visitor_, CreateContextForMultiPortPath)
-      .WillRepeatedly(testing::WithArgs<0>([&](auto&& fn) {
-        fn(std::move(std::make_unique<TestQuicPathValidationContext>(
-            kNewSelfAddress, connection_.peer_address(), &new_writer)));
+      .WillRepeatedly(testing::WithArgs<0>([&](auto&& observer) {
+        observer->OnMultiPortPathContextAvailable(
+            std::move(std::make_unique<TestQuicPathValidationContext>(
+                kNewSelfAddress, connection_.peer_address(), &new_writer)));
       }));
   connection_.OnNewConnectionIdFrame(frame);
   EXPECT_TRUE(connection_.HasPendingPathValidation());
@@ -13519,9 +13520,10 @@
   frame.retire_prior_to = 0u;
   frame.sequence_number = 1u;
   EXPECT_CALL(visitor_, CreateContextForMultiPortPath)
-      .WillRepeatedly(testing::WithArgs<0>([&](auto&& fn) {
-        fn(std::move(std::make_unique<TestQuicPathValidationContext>(
-            kNewSelfAddress, connection_.peer_address(), &new_writer)));
+      .WillRepeatedly(testing::WithArgs<0>([&](auto&& observer) {
+        observer->OnMultiPortPathContextAvailable(
+            std::move(std::make_unique<TestQuicPathValidationContext>(
+                kNewSelfAddress, connection_.peer_address(), &new_writer)));
       }));
   EXPECT_TRUE(connection_.OnNewConnectionIdFrame(frame));
   EXPECT_TRUE(connection_.HasPendingPathValidation());
@@ -13558,9 +13560,10 @@
     frame.retire_prior_to = 0u;
     frame.sequence_number = i + 2;
     EXPECT_CALL(visitor_, CreateContextForMultiPortPath)
-        .WillRepeatedly(testing::WithArgs<0>([&](auto&& fn) {
-          fn(std::move(std::make_unique<TestQuicPathValidationContext>(
-              kNewSelfAddress, connection_.peer_address(), &new_writer)));
+        .WillRepeatedly(testing::WithArgs<0>([&](auto&& observer) {
+          observer->OnMultiPortPathContextAvailable(
+              std::move(std::make_unique<TestQuicPathValidationContext>(
+                  kNewSelfAddress, connection_.peer_address(), &new_writer)));
         }));
     EXPECT_TRUE(connection_.OnNewConnectionIdFrame(frame));
     EXPECT_TRUE(connection_.HasPendingPathValidation());
@@ -13630,9 +13633,10 @@
   frame.retire_prior_to = 0u;
   frame.sequence_number = 1u;
   EXPECT_CALL(visitor_, CreateContextForMultiPortPath)
-      .WillRepeatedly(testing::WithArgs<0>([&](auto&& fn) {
-        fn(std::move(std::make_unique<TestQuicPathValidationContext>(
-            kNewSelfAddress, connection_.peer_address(), &new_writer)));
+      .WillRepeatedly(testing::WithArgs<0>([&](auto&& observer) {
+        observer->OnMultiPortPathContextAvailable(
+            std::move(std::make_unique<TestQuicPathValidationContext>(
+                kNewSelfAddress, connection_.peer_address(), &new_writer)));
       }));
   EXPECT_TRUE(connection_.OnNewConnectionIdFrame(frame));
   EXPECT_TRUE(connection_.HasPendingPathValidation());
@@ -13700,9 +13704,10 @@
   frame.retire_prior_to = 0u;
   frame.sequence_number = 1u;
   EXPECT_CALL(visitor_, CreateContextForMultiPortPath)
-      .WillRepeatedly(testing::WithArgs<0>([&](auto&& fn) {
-        fn(std::move(std::make_unique<TestQuicPathValidationContext>(
-            kNewSelfAddress, connection_.peer_address(), &new_writer)));
+      .WillRepeatedly(testing::WithArgs<0>([&](auto&& observer) {
+        observer->OnMultiPortPathContextAvailable(
+            std::move(std::make_unique<TestQuicPathValidationContext>(
+                kNewSelfAddress, connection_.peer_address(), &new_writer)));
       }));
   EXPECT_TRUE(connection_.OnNewConnectionIdFrame(frame));
   EXPECT_TRUE(connection_.HasPendingPathValidation());
@@ -13778,9 +13783,10 @@
   frame.retire_prior_to = 0u;
   frame.sequence_number = 1u;
   EXPECT_CALL(visitor_, CreateContextForMultiPortPath)
-      .WillRepeatedly(testing::WithArgs<0>([&](auto&& fn) {
-        fn(std::move(std::make_unique<TestQuicPathValidationContext>(
-            kNewSelfAddress, connection_.peer_address(), &new_writer)));
+      .WillRepeatedly(testing::WithArgs<0>([&](auto&& observer) {
+        observer->OnMultiPortPathContextAvailable(
+            std::move(std::make_unique<TestQuicPathValidationContext>(
+                kNewSelfAddress, connection_.peer_address(), &new_writer)));
       }));
   EXPECT_TRUE(connection_.OnNewConnectionIdFrame(frame));
   EXPECT_TRUE(connection_.HasPendingPathValidation());
@@ -16849,9 +16855,10 @@
   frame.retire_prior_to = 0u;
   frame.sequence_number = 2u;
   EXPECT_CALL(visitor_, CreateContextForMultiPortPath)
-      .WillOnce(testing::WithArgs<0>([&](auto&& fn) {
-        fn(std::move(std::make_unique<TestQuicPathValidationContext>(
-            kNewSelfAddress2, connection_.peer_address(), &new_writer2)));
+      .WillOnce(testing::WithArgs<0>([&](auto&& observer) {
+        observer->OnMultiPortPathContextAvailable(
+            std::move(std::make_unique<TestQuicPathValidationContext>(
+                kNewSelfAddress2, connection_.peer_address(), &new_writer2)));
       }));
   connection_.OnNewConnectionIdFrame(frame);
   EXPECT_TRUE(connection_.HasPendingPathValidation());
diff --git a/quiche/quic/core/quic_session.h b/quiche/quic/core/quic_session.h
index 1034a3c..05e8ab3 100644
--- a/quiche/quic/core/quic_session.h
+++ b/quiche/quic/core/quic_session.h
@@ -182,10 +182,8 @@
   bool MaybeSendAddressToken() override;
   void OnBandwidthUpdateTimeout() override {}
   void CreateContextForMultiPortPath(
-      std::function<void(std::unique_ptr<QuicPathValidationContext>)>
-          create_context) override {
-    create_context(nullptr);
-  }
+      std::unique_ptr<MultiPortPathContextObserver> /*context_observer*/)
+      override {}
   void MigrateToMultiPortPath(
       std::unique_ptr<QuicPathValidationContext> /*context*/) override {}
   void OnServerPreferredAddressAvailable(
diff --git a/quiche/quic/test_tools/quic_test_utils.h b/quiche/quic/test_tools/quic_test_utils.h
index c21107c..25cc2d4 100644
--- a/quiche/quic/test_tools/quic_test_utils.h
+++ b/quiche/quic/test_tools/quic_test_utils.h
@@ -505,8 +505,7 @@
   MOCK_METHOD(bool, ValidateToken, (absl::string_view), (override));
   MOCK_METHOD(bool, MaybeSendAddressToken, (), (override));
   MOCK_METHOD(void, CreateContextForMultiPortPath,
-              (std::function<void(std::unique_ptr<QuicPathValidationContext>)>),
-              (override));
+              (std::unique_ptr<MultiPortPathContextObserver>), (override));
   MOCK_METHOD(void, MigrateToMultiPortPath,
               (std::unique_ptr<QuicPathValidationContext>), (override));
   MOCK_METHOD(void, OnServerPreferredAddressAvailable,
diff --git a/quiche/quic/test_tools/simulator/quic_endpoint.h b/quiche/quic/test_tools/simulator/quic_endpoint.h
index 29b72c5..84f5ad9 100644
--- a/quiche/quic/test_tools/simulator/quic_endpoint.h
+++ b/quiche/quic/test_tools/simulator/quic_endpoint.h
@@ -106,10 +106,8 @@
   bool MaybeSendAddressToken() override { return false; }
   void OnBandwidthUpdateTimeout() override {}
   void CreateContextForMultiPortPath(
-      std::function<void(std::unique_ptr<QuicPathValidationContext>)>
-          create_context) override {
-    create_context(nullptr);
-  }
+      std::unique_ptr<MultiPortPathContextObserver> /*context_observer*/)
+      override {}
   void MigrateToMultiPortPath(
       std::unique_ptr<QuicPathValidationContext> /*context*/) override {}
   void OnServerPreferredAddressAvailable(
diff --git a/quiche/quic/tools/quic_simple_client_session.cc b/quiche/quic/tools/quic_simple_client_session.cc
index 0bb1515..c2c266f 100644
--- a/quiche/quic/tools/quic_simple_client_session.cc
+++ b/quiche/quic/tools/quic_simple_client_session.cc
@@ -53,27 +53,24 @@
 }
 
 void QuicSimpleClientSession::CreateContextForMultiPortPath(
-    std::function<void(std::unique_ptr<QuicPathValidationContext>)>
-        create_context) {
+    std::unique_ptr<MultiPortPathContextObserver> context_observer) {
   if (!network_helper_ || connection()->multi_port_stats() == nullptr) {
-    create_context(nullptr);
     return;
   }
   auto self_address = connection()->self_address();
   auto server_address = connection()->peer_address();
   if (!network_helper_->CreateUDPSocketAndBind(
           server_address, self_address.host(), self_address.port() + 1)) {
-    create_context(nullptr);
     return;
   }
   QuicPacketWriter* writer = network_helper_->CreateQuicPacketWriter();
   if (writer == nullptr) {
-    create_context(nullptr);
     return;
   }
-  create_context(std::make_unique<PathMigrationContext>(
-      std::unique_ptr<QuicPacketWriter>(writer),
-      network_helper_->GetLatestClientAddress(), peer_address()));
+  context_observer->OnMultiPortPathContextAvailable(
+      std::make_unique<PathMigrationContext>(
+          std::unique_ptr<QuicPacketWriter>(writer),
+          network_helper_->GetLatestClientAddress(), peer_address()));
 }
 
 void QuicSimpleClientSession::MigrateToMultiPortPath(
diff --git a/quiche/quic/tools/quic_simple_client_session.h b/quiche/quic/tools/quic_simple_client_session.h
index 2a0db5d..1017341 100644
--- a/quiche/quic/tools/quic_simple_client_session.h
+++ b/quiche/quic/tools/quic_simple_client_session.h
@@ -40,8 +40,7 @@
   bool ShouldNegotiateWebTransport() override;
   HttpDatagramSupport LocalHttpDatagramSupport() override;
   void CreateContextForMultiPortPath(
-      std::function<void(std::unique_ptr<QuicPathValidationContext>)>
-          create_context) override;
+      std::unique_ptr<MultiPortPathContextObserver> context_observer) override;
   void MigrateToMultiPortPath(
       std::unique_ptr<QuicPathValidationContext> context) override;
   bool drop_response_body() const { return drop_response_body_; }