grpc 1.65.2 → 1.66.0.pre3

data/src/core/ext/upbdefs-gen/google/protobuf/descriptor.upbdefs.h

@@ -108,6 +108,11 @@ UPB_INLINE const upb_MessageDef *google_protobuf_FieldOptions_EditionDefault_get
   return upb_DefPool_FindMessageByName(s, "google.protobuf.FieldOptions.EditionDefault");
 }
 
+UPB_INLINE const upb_MessageDef *google_protobuf_FieldOptions_FeatureSupport_getmsgdef(upb_DefPool *s) {
+  _upb_DefPool_LoadDefInit(s, &google_protobuf_descriptor_proto_upbdefinit);
+  return upb_DefPool_FindMessageByName(s, "google.protobuf.FieldOptions.FeatureSupport");
+}
+
 UPB_INLINE const upb_MessageDef *google_protobuf_OneofOptions_getmsgdef(upb_DefPool *s) {
   _upb_DefPool_LoadDefInit(s, &google_protobuf_descriptor_proto_upbdefinit);
   return upb_DefPool_FindMessageByName(s, "google.protobuf.OneofOptions");

data/src/core/handshaker/endpoint_info/endpoint_info_handshaker.cc

@@ -17,7 +17,9 @@
 #include "src/core/handshaker/endpoint_info/endpoint_info_handshaker.h"
 
 #include <memory>
+#include <utility>
 
+#include "absl/functional/any_invocable.h"
 #include "absl/status/status.h"
 
 #include <grpc/support/port_platform.h>
@@ -38,17 +40,17 @@ namespace {
 
 class EndpointInfoHandshaker : public Handshaker {
  public:
-  const char* name() const override { return "endpoint_info"; }
+  absl::string_view name() const override { return "endpoint_info"; }
 
-  void DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
-                   grpc_closure* on_handshake_done,
-                   HandshakerArgs* args) override {
+  void DoHandshake(
+      HandshakerArgs* args,
+      absl::AnyInvocable<void(absl::Status)> on_handshake_done) override {
     args->args = args->args
                      .Set(GRPC_ARG_ENDPOINT_LOCAL_ADDRESS,
-                          grpc_endpoint_get_local_address(args->endpoint))
+                          grpc_endpoint_get_local_address(args->endpoint.get()))
                      .Set(GRPC_ARG_ENDPOINT_PEER_ADDRESS,
-                          grpc_endpoint_get_peer(args->endpoint));
-    ExecCtx::Run(DEBUG_LOCATION, on_handshake_done, absl::OkStatus());
+                          grpc_endpoint_get_peer(args->endpoint.get()));
+    InvokeOnHandshakeDone(args, std::move(on_handshake_done), absl::OkStatus());
   }
 
   void Shutdown(grpc_error_handle /*why*/) override {}

data/src/core/handshaker/handshaker.cc

@@ -23,38 +23,54 @@
 #include <string>
 #include <utility>
 
+#include "absl/functional/any_invocable.h"
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/byte_buffer.h>
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/status_helper.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/event_engine_shims/endpoint.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 
+using ::grpc_event_engine::experimental::EventEngine;
+
 namespace grpc_core {
 
-namespace {
+void Handshaker::InvokeOnHandshakeDone(
+    HandshakerArgs* args,
+    absl::AnyInvocable<void(absl::Status)> on_handshake_done,
+    absl::Status status) {
+  args->event_engine->Run([on_handshake_done = std::move(on_handshake_done),
+                           status = std::move(status)]() mutable {
+    ApplicationCallbackExecCtx callback_exec_ctx;
+    ExecCtx exec_ctx;
+    on_handshake_done(std::move(status));
+    // Destroy callback while ExecCtx is still in scope.
+    on_handshake_done = nullptr;
+  });
+}
 
-using ::grpc_event_engine::experimental::EventEngine;
+namespace {
 
 std::string HandshakerArgsString(HandshakerArgs* args) {
-  size_t read_buffer_length =
-      args->read_buffer != nullptr ? args->read_buffer->length : 0;
-  return absl::StrFormat(
-      "{endpoint=%p, args=%s, read_buffer=%p (length=%" PRIuPTR
-      "), exit_early=%d}",
-      args->endpoint, args->args.ToString(), args->read_buffer,
-      read_buffer_length, args->exit_early);
+  return absl::StrFormat("{endpoint=%p, args=%s, read_buffer.Length()=%" PRIuPTR
+                         ", exit_early=%d}",
+                         args->endpoint.get(), args->args.ToString(),
+                         args->read_buffer.Length(), args->exit_early);
 }
 
 }  // namespace
@@ -66,158 +82,129 @@ HandshakeManager::HandshakeManager()
 void HandshakeManager::Add(RefCountedPtr<Handshaker> handshaker) {
   MutexLock lock(&mu_);
   if (GRPC_TRACE_FLAG_ENABLED(handshaker)) {
-    gpr_log(
-        GPR_INFO,
-        "handshake_manager %p: adding handshaker %s [%p] at index %" PRIuPTR,
-        this, handshaker->name(), handshaker.get(), handshakers_.size());
+    LOG(INFO) << "handshake_manager " << this << ": adding handshaker "
+              << std::string(handshaker->name()) << " [" << handshaker.get()
+              << "] at index " << handshakers_.size();
   }
   handshakers_.push_back(std::move(handshaker));
 }
 
-HandshakeManager::~HandshakeManager() { handshakers_.clear(); }
+void HandshakeManager::DoHandshake(
+    OrphanablePtr<grpc_endpoint> endpoint, const ChannelArgs& channel_args,
+    Timestamp deadline, grpc_tcp_server_acceptor* acceptor,
+    absl::AnyInvocable<void(absl::StatusOr<HandshakerArgs*>)>
+        on_handshake_done) {
+  // We hold a ref until after the mutex is released, because we might
+  // wind up invoking on_handshake_done in another thread before we
+  // return from this function, and on_handshake_done might release the
+  // last ref to this object.
+  auto self = Ref();
+  MutexLock lock(&mu_);
+  CHECK_EQ(index_, 0u);
+  on_handshake_done_ = std::move(on_handshake_done);
+  // Construct handshaker args.  These will be passed through all
+  // handshakers and eventually be freed by the on_handshake_done callback.
+  args_.endpoint = std::move(endpoint);
+  args_.deadline = deadline;
+  args_.args = channel_args;
+  args_.event_engine = args_.args.GetObject<EventEngine>();
+  args_.acceptor = acceptor;
+  if (acceptor != nullptr && acceptor->external_connection &&
+      acceptor->pending_data != nullptr) {
+    grpc_slice_buffer_swap(args_.read_buffer.c_slice_buffer(),
+                           &(acceptor->pending_data->data.raw.slice_buffer));
+    // TODO(vigneshbabu): For connections accepted through event engine
+    // listeners, the ownership of the byte buffer received is transferred to
+    // this callback and it is thus this callback's duty to delete it.
+    // Make this hack default once event engine is rolled out.
+    if (grpc_event_engine::experimental::grpc_is_event_engine_endpoint(
+            args_.endpoint.get())) {
+      grpc_byte_buffer_destroy(acceptor->pending_data);
+    }
+  }
+  // Start deadline timer, which owns a ref.
+  const Duration time_to_deadline = deadline - Timestamp::Now();
+  deadline_timer_handle_ =
+      args_.event_engine->RunAfter(time_to_deadline, [self = Ref()]() mutable {
+        ApplicationCallbackExecCtx callback_exec_ctx;
+        ExecCtx exec_ctx;
+        self->Shutdown(GRPC_ERROR_CREATE("Handshake timed out"));
+        // HandshakeManager deletion might require an active ExecCtx.
+        self.reset();
+      });
+  // Start first handshaker.
+  CallNextHandshakerLocked(absl::OkStatus());
+}
 
-void HandshakeManager::Shutdown(grpc_error_handle why) {
-  {
-    MutexLock lock(&mu_);
+void HandshakeManager::Shutdown(absl::Status error) {
+  MutexLock lock(&mu_);
+  if (!is_shutdown_) {
+    if (GRPC_TRACE_FLAG_ENABLED(handshaker)) {
+      LOG(INFO) << "handshake_manager " << this
+                << ": Shutdown() called: " << error;
+    }
+    is_shutdown_ = true;
     // Shutdown the handshaker that's currently in progress, if any.
-    if (!is_shutdown_ && index_ > 0) {
-      is_shutdown_ = true;
-      handshakers_[index_ - 1]->Shutdown(why);
+    if (index_ > 0) {
+      if (GRPC_TRACE_FLAG_ENABLED(handshaker)) {
+        LOG(INFO) << "handshake_manager " << this
+                  << ": shutting down handshaker at index " << index_ - 1;
+      }
+      handshakers_[index_ - 1]->Shutdown(std::move(error));
     }
   }
 }
 
-// Helper function to call either the next handshaker or the
-// on_handshake_done callback.
-// Returns true if we've scheduled the on_handshake_done callback.
-bool HandshakeManager::CallNextHandshakerLocked(grpc_error_handle error) {
+void HandshakeManager::CallNextHandshakerLocked(absl::Status error) {
   if (GRPC_TRACE_FLAG_ENABLED(handshaker)) {
-    gpr_log(GPR_INFO,
-            "handshake_manager %p: error=%s shutdown=%d index=%" PRIuPTR
-            ", args=%s",
-            this, StatusToString(error).c_str(), is_shutdown_, index_,
-            HandshakerArgsString(&args_).c_str());
+    LOG(INFO) << "handshake_manager " << this << ": error=" << error
+              << " shutdown=" << is_shutdown_ << " index=" << index_
+              << ", args=" << HandshakerArgsString(&args_);
   }
   CHECK(index_ <= handshakers_.size());
   // If we got an error or we've been shut down or we're exiting early or
   // we've finished the last handshaker, invoke the on_handshake_done
-  // callback.  Otherwise, call the next handshaker.
+  // callback.
   if (!error.ok() || is_shutdown_ || args_.exit_early ||
       index_ == handshakers_.size()) {
     if (error.ok() && is_shutdown_) {
       error = GRPC_ERROR_CREATE("handshaker shutdown");
-      // It is possible that the endpoint has already been destroyed by
-      // a shutdown call while this callback was sitting on the ExecCtx
-      // with no error.
-      if (args_.endpoint != nullptr) {
-        grpc_endpoint_destroy(args_.endpoint);
-        args_.endpoint = nullptr;
-      }
-      if (args_.read_buffer != nullptr) {
-        grpc_slice_buffer_destroy(args_.read_buffer);
-        gpr_free(args_.read_buffer);
-        args_.read_buffer = nullptr;
-      }
-      args_.args = ChannelArgs();
+      args_.endpoint.reset();
     }
     if (GRPC_TRACE_FLAG_ENABLED(handshaker)) {
-      gpr_log(GPR_INFO,
-              "handshake_manager %p: handshaking complete -- scheduling "
-              "on_handshake_done with error=%s",
-              this, StatusToString(error).c_str());
+      LOG(INFO) << "handshake_manager " << this
+                << ": handshaking complete -- scheduling "
+                   "on_handshake_done with error="
+                << error;
     }
     // Cancel deadline timer, since we're invoking the on_handshake_done
     // callback now.
-    event_engine_->Cancel(deadline_timer_handle_);
-    ExecCtx::Run(DEBUG_LOCATION, &on_handshake_done_, error);
+    args_.event_engine->Cancel(deadline_timer_handle_);
     is_shutdown_ = true;
-  } else {
-    auto handshaker = handshakers_[index_];
-    if (GRPC_TRACE_FLAG_ENABLED(handshaker)) {
-      gpr_log(
-          GPR_INFO,
-          "handshake_manager %p: calling handshaker %s [%p] at index %" PRIuPTR,
-          this, handshaker->name(), handshaker.get(), index_);
-    }
-    handshaker->DoHandshake(acceptor_, &call_next_handshaker_, &args_);
-  }
-  ++index_;
-  return is_shutdown_;
-}
-
-void HandshakeManager::CallNextHandshakerFn(void* arg,
-                                            grpc_error_handle error) {
-  auto* mgr = static_cast<HandshakeManager*>(arg);
-  bool done;
-  {
-    MutexLock lock(&mgr->mu_);
-    done = mgr->CallNextHandshakerLocked(error);
-  }
-  // If we're invoked the final callback, we won't be coming back
-  // to this function, so we can release our reference to the
-  // handshake manager.
-  if (done) {
-    mgr->Unref();
+    absl::StatusOr<HandshakerArgs*> result(&args_);
+    if (!error.ok()) result = std::move(error);
+    args_.event_engine->Run([on_handshake_done = std::move(on_handshake_done_),
+                             result = std::move(result)]() mutable {
+      ApplicationCallbackExecCtx callback_exec_ctx;
+      ExecCtx exec_ctx;
+      on_handshake_done(std::move(result));
+      // Destroy callback while ExecCtx is still in scope.
+      on_handshake_done = nullptr;
+    });
+    return;
   }
-}
-
-void HandshakeManager::DoHandshake(grpc_endpoint* endpoint,
-                                   const ChannelArgs& channel_args,
-                                   Timestamp deadline,
-                                   grpc_tcp_server_acceptor* acceptor,
-                                   grpc_iomgr_cb_func on_handshake_done,
-                                   void* user_data) {
-  bool done;
-  {
-    MutexLock lock(&mu_);
-    CHECK_EQ(index_, 0u);
-    // Construct handshaker args.  These will be passed through all
-    // handshakers and eventually be freed by the on_handshake_done callback.
-    args_.endpoint = endpoint;
-    args_.deadline = deadline;
-    args_.args = channel_args;
-    args_.user_data = user_data;
-    args_.read_buffer =
-        static_cast<grpc_slice_buffer*>(gpr_malloc(sizeof(*args_.read_buffer)));
-    grpc_slice_buffer_init(args_.read_buffer);
-    if (acceptor != nullptr && acceptor->external_connection &&
-        acceptor->pending_data != nullptr) {
-      grpc_slice_buffer_swap(args_.read_buffer,
-                             &(acceptor->pending_data->data.raw.slice_buffer));
-      // TODO(vigneshbabu): For connections accepted through event engine
-      // listeners, the ownership of the byte buffer received is transferred to
-      // this callback and it is thus this callback's duty to delete it.
-      // Make this hack default once event engine is rolled out.
-      if (grpc_event_engine::experimental::grpc_is_event_engine_endpoint(
-              endpoint)) {
-        grpc_byte_buffer_destroy(acceptor->pending_data);
-      }
-    }
-    // Initialize state needed for calling handshakers.
-    acceptor_ = acceptor;
-    GRPC_CLOSURE_INIT(&call_next_handshaker_,
-                      &HandshakeManager::CallNextHandshakerFn, this,
-                      grpc_schedule_on_exec_ctx);
-    GRPC_CLOSURE_INIT(&on_handshake_done_, on_handshake_done, &args_,
-                      grpc_schedule_on_exec_ctx);
-    // Start deadline timer, which owns a ref.
-    const Duration time_to_deadline = deadline - Timestamp::Now();
-    event_engine_ = args_.args.GetObjectRef<EventEngine>();
-    deadline_timer_handle_ =
-        event_engine_->RunAfter(time_to_deadline, [self = Ref()]() mutable {
-          ApplicationCallbackExecCtx callback_exec_ctx;
-          ExecCtx exec_ctx;
-          self->Shutdown(GRPC_ERROR_CREATE("Handshake timed out"));
-          // HandshakeManager deletion might require an active ExecCtx.
-          self.reset();
-        });
-    // Start first handshaker, which also owns a ref.
-    Ref().release();
-    done = CallNextHandshakerLocked(absl::OkStatus());
-  }
-  if (done) {
-    Unref();
+  // Call the next handshaker.
+  auto handshaker = handshakers_[index_];
+  if (GRPC_TRACE_FLAG_ENABLED(handshaker)) {
+    LOG(INFO) << "handshake_manager " << this << ": calling handshaker "
+              << handshaker->name() << " [" << handshaker.get() << "] at index "
+              << index_;
   }
+  ++index_;
+  handshaker->DoHandshake(&args_, [self = Ref()](absl::Status error) mutable {
+    MutexLock lock(&self->mu_);
+    self->CallNextHandshakerLocked(std::move(error));
+  });
 }
 
 }  // namespace grpc_core

data/src/core/handshaker/handshaker.h

@@ -31,6 +31,7 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -39,6 +40,7 @@
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/tcp_server.h"
+#include "src/core/lib/slice/slice_buffer.h"
 
 namespace grpc_core {
 
@@ -49,34 +51,35 @@ namespace grpc_core {
 ///
 /// In general, handshakers should be used via a handshake manager.
 
-/// Arguments passed through handshakers and to the on_handshake_done callback.
+/// Arguments passed through handshakers and back to the caller.
 ///
 /// For handshakers, all members are input/output parameters; for
 /// example, a handshaker may read from or write to \a endpoint and
 /// then later replace it with a wrapped endpoint.  Similarly, a
 /// handshaker may modify \a args.
 ///
-/// A handshaker takes ownership of the members while a handshake is in
-/// progress.  Upon failure or shutdown of an in-progress handshaker,
-/// the handshaker is responsible for destroying the members and setting
-/// them to NULL before invoking the on_handshake_done callback.
-///
-/// For the on_handshake_done callback, all members are input arguments,
-/// which the callback takes ownership of.
+/// A handshaker takes ownership of the members when this struct is
+/// passed to DoHandshake().  It passes ownership back to the caller
+/// when it invokes on_handshake_done.
 struct HandshakerArgs {
-  grpc_endpoint* endpoint = nullptr;
+  OrphanablePtr<grpc_endpoint> endpoint;
   ChannelArgs args;
-  grpc_slice_buffer* read_buffer = nullptr;
+  // Any bytes read from the endpoint that are not consumed by the
+  // handshaker must be passed back via this buffer.
+  SliceBuffer read_buffer;
   // A handshaker may set this to true before invoking on_handshake_done
   // to indicate that subsequent handshakers should be skipped.
   bool exit_early = false;
-  // User data passed through the handshake manager.  Not used by
-  // individual handshakers.
-  void* user_data = nullptr;
+  // EventEngine to use for async work.
+  // (This is just a convenience to avoid digging it out of args.)
+  grpc_event_engine::experimental::EventEngine* event_engine = nullptr;
   // Deadline associated with the handshake.
   // TODO(anramach): Move this out of handshake args after EventEngine
   // is the default.
   Timestamp deadline;
+  // TODO(roth): Make this go away somehow as part of the EventEngine
+  // migration?
+  grpc_tcp_server_acceptor* acceptor = nullptr;
 };
 
 ///
@@ -86,11 +89,23 @@ struct HandshakerArgs {
 class Handshaker : public RefCounted<Handshaker> {
  public:
   ~Handshaker() override = default;
-  virtual void Shutdown(grpc_error_handle why) = 0;
-  virtual void DoHandshake(grpc_tcp_server_acceptor* acceptor,
-                           grpc_closure* on_handshake_done,
-                           HandshakerArgs* args) = 0;
-  virtual const char* name() const = 0;
+  virtual absl::string_view name() const = 0;
+  virtual void DoHandshake(
+      HandshakerArgs* args,
+      absl::AnyInvocable<void(absl::Status)> on_handshake_done) = 0;
+  virtual void Shutdown(absl::Status error) = 0;
+
+ protected:
+  // Helper function to safely invoke on_handshake_done asynchronously.
+  //
+  // Note that on_handshake_done may complete in another thread as soon
+  // as this method returns, so the handshaker object may be destroyed
+  // by the callback unless the caller of this method is holding its own
+  // ref to the handshaker.
+  static void InvokeOnHandshakeDone(
+      HandshakerArgs* args,
+      absl::AnyInvocable<void(absl::Status)> on_handshake_done,
+      absl::Status status);
 };
 
 //
@@ -100,16 +115,11 @@ class Handshaker : public RefCounted<Handshaker> {
 class HandshakeManager : public RefCounted<HandshakeManager> {
  public:
   HandshakeManager();
-  ~HandshakeManager() override;
 
   /// Adds a handshaker to the handshake manager.
   /// Takes ownership of \a handshaker.
   void Add(RefCountedPtr<Handshaker> handshaker) ABSL_LOCKS_EXCLUDED(mu_);
 
-  /// Shuts down the handshake manager (e.g., to clean up when the operation is
-  /// aborted in the middle).
-  void Shutdown(grpc_error_handle why) ABSL_LOCKS_EXCLUDED(mu_);
-
   /// Invokes handshakers in the order they were added.
   /// Takes ownership of \a endpoint, and then passes that ownership to
   /// the \a on_handshake_done callback.
@@ -122,41 +132,39 @@ class HandshakeManager : public RefCounted<HandshakeManager> {
   /// absl::OkStatus(), then handshaking failed and the handshaker has done
   /// the necessary clean-up.  Otherwise, the callback takes ownership of
   /// the arguments.
-  void DoHandshake(grpc_endpoint* endpoint, const ChannelArgs& channel_args,
-                   Timestamp deadline, grpc_tcp_server_acceptor* acceptor,
-                   grpc_iomgr_cb_func on_handshake_done, void* user_data)
-      ABSL_LOCKS_EXCLUDED(mu_);
+  void DoHandshake(OrphanablePtr<grpc_endpoint> endpoint,
+                   const ChannelArgs& channel_args, Timestamp deadline,
+                   grpc_tcp_server_acceptor* acceptor,
+                   absl::AnyInvocable<void(absl::StatusOr<HandshakerArgs*>)>
+                       on_handshake_done) ABSL_LOCKS_EXCLUDED(mu_);
 
- private:
-  bool CallNextHandshakerLocked(grpc_error_handle error)
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  /// Shuts down the handshake manager (e.g., to clean up when the operation is
+  /// aborted in the middle).
+  void Shutdown(absl::Status error) ABSL_LOCKS_EXCLUDED(mu_);
 
+ private:
   // A function used as the handshaker-done callback when chaining
   // handshakers together.
-  static void CallNextHandshakerFn(void* arg, grpc_error_handle error)
-      ABSL_LOCKS_EXCLUDED(mu_);
+  void CallNextHandshakerLocked(absl::Status error)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
-  static const size_t HANDSHAKERS_INIT_SIZE = 2;
+  static const size_t kHandshakerListInlineSize = 2;
 
   Mutex mu_;
   bool is_shutdown_ ABSL_GUARDED_BY(mu_) = false;
-  // An array of handshakers added via grpc_handshake_manager_add().
-  absl::InlinedVector<RefCountedPtr<Handshaker>, HANDSHAKERS_INIT_SIZE>
-      handshakers_ ABSL_GUARDED_BY(mu_);
   // The index of the handshaker to invoke next and closure to invoke it.
   size_t index_ ABSL_GUARDED_BY(mu_) = 0;
-  grpc_closure call_next_handshaker_ ABSL_GUARDED_BY(mu_);
-  // The acceptor to call the handshakers with.
-  grpc_tcp_server_acceptor* acceptor_ ABSL_GUARDED_BY(mu_);
-  // The final callback and user_data to invoke after the last handshaker.
-  grpc_closure on_handshake_done_ ABSL_GUARDED_BY(mu_);
+  // An array of handshakers added via Add().
+  absl::InlinedVector<RefCountedPtr<Handshaker>, kHandshakerListInlineSize>
+      handshakers_ ABSL_GUARDED_BY(mu_);
   // Handshaker args.
   HandshakerArgs args_ ABSL_GUARDED_BY(mu_);
+  // The final callback to invoke after the last handshaker.
+  absl::AnyInvocable<void(absl::StatusOr<HandshakerArgs*>)> on_handshake_done_
+      ABSL_GUARDED_BY(mu_);
   // Deadline timer across all handshakers.
   grpc_event_engine::experimental::EventEngine::TaskHandle
       deadline_timer_handle_ ABSL_GUARDED_BY(mu_);
-  std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine_
-      ABSL_GUARDED_BY(mu_);
 };
 
 }  // namespace grpc_core