grpc 1.52.0.pre2 → 1.53.0.pre2

data/src/core/lib/surface/server.cc

@@ -24,14 +24,19 @@
 
 #include <algorithm>
 #include <atomic>
+#include <initializer_list>
 #include <list>
 #include <new>
 #include <queue>
+#include <tuple>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
+#include "absl/cleanup/cleanup.h"
 #include "absl/status/status.h"
 #include "absl/types/optional.h"
+#include "absl/types/variant.h"
 
 #include <grpc/byte_buffer.h>
 #include <grpc/impl/connectivity_state.h>
@@ -44,13 +49,26 @@
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/match.h"
 #include "src/core/lib/gprpp/mpscq.h"
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/promise/detail/basic_join.h"
+#include "src/core/lib/promise/detail/basic_seq.h"
+#include "src/core/lib/promise/map.h"
+#include "src/core/lib/promise/pipe.h"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/promise/promise.h"
+#include "src/core/lib/promise/try_join.h"
+#include "src/core/lib/promise/try_seq.h"
+#include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/call.h"
@@ -177,6 +195,20 @@ class Server::RequestMatcherInterface {
   virtual void RequestCallWithPossiblePublish(size_t request_queue_index,
                                               RequestedCall* call) = 0;
 
+  struct MatchResult {
+    size_t cq_idx;
+    RequestedCall* requested_call;
+  };
+
+  // This function is invoked on an incoming promise based RPC.
+  // The RequestMatcher will try to match it against an application-requested
+  // RPC if possible or will place it in the pending queue otherwise. To enable
+  // some measure of fairness between server CQs, the match is done starting at
+  // the start_request_queue_index parameter in a cyclic order rather than
+  // always starting at 0.
+  virtual ArenaPromise<absl::StatusOr<MatchResult>> MatchRequest(
+      size_t start_request_queue_index) = 0;
+
   // This function is invoked on an incoming RPC, represented by the calld
   // object. The RequestMatcher will try to match it against an
   // application-requested RPC if possible or will place it in the pending queue
@@ -208,9 +240,15 @@ class Server::RealRequestMatcher : public RequestMatcherInterface {
 
   void ZombifyPending() override {
     while (!pending_.empty()) {
-      CallData* calld = pending_.front();
-      calld->SetState(CallData::CallState::ZOMBIED);
-      calld->KillZombie();
+      Match(
+          pending_.front(),
+          [](CallData* calld) {
+            calld->SetState(CallData::CallState::ZOMBIED);
+            calld->KillZombie();
+          },
+          [](const std::shared_ptr<ActivityWaiter>& w) {
+            w->Finish(absl::InternalError("Server closed"));
+          });
       pending_.pop();
     }
   }
@@ -234,19 +272,19 @@ class Server::RealRequestMatcher : public RequestMatcherInterface {
     if (requests_per_cq_[request_queue_index].Push(&call->mpscq_node)) {
       // this was the first queued request: we need to lock and start
       // matching calls
-      struct PendingCall {
+      struct NextPendingCall {
         RequestedCall* rc = nullptr;
-        CallData* calld;
+        PendingCall pending;
       };
       auto pop_next_pending = [this, request_queue_index] {
-        PendingCall pending_call;
+        NextPendingCall pending_call;
         {
           MutexLock lock(&server_->mu_call_);
           if (!pending_.empty()) {
             pending_call.rc = reinterpret_cast<RequestedCall*>(
                 requests_per_cq_[request_queue_index].Pop());
             if (pending_call.rc != nullptr) {
-              pending_call.calld = pending_.front();
+              pending_call.pending = std::move(pending_.front());
               pending_.pop();
             }
           }
@@ -254,14 +292,20 @@ class Server::RealRequestMatcher : public RequestMatcherInterface {
         return pending_call;
       };
       while (true) {
-        PendingCall next_pending = pop_next_pending();
+        NextPendingCall next_pending = pop_next_pending();
         if (next_pending.rc == nullptr) break;
-        if (!next_pending.calld->MaybeActivate()) {
-          // Zombied Call
-          next_pending.calld->KillZombie();
-        } else {
-          next_pending.calld->Publish(request_queue_index, next_pending.rc);
-        }
+        auto mr = MatchResult{request_queue_index, next_pending.rc};
+        Match(
+            next_pending.pending,
+            [mr](CallData* calld) {
+              if (!calld->MaybeActivate()) {
+                // Zombied Call
+                calld->KillZombie();
+              } else {
+                calld->Publish(mr.cq_idx, mr.requested_call);
+              }
+            },
+            [mr](const std::shared_ptr<ActivityWaiter>& w) { w->Finish(mr); });
       }
     }
   }
@@ -306,11 +350,66 @@ class Server::RealRequestMatcher : public RequestMatcherInterface {
     calld->Publish(cq_idx, rc);
   }
 
+  ArenaPromise<absl::StatusOr<MatchResult>> MatchRequest(
+      size_t start_request_queue_index) override {
+    for (size_t i = 0; i < requests_per_cq_.size(); i++) {
+      size_t cq_idx = (start_request_queue_index + i) % requests_per_cq_.size();
+      RequestedCall* rc =
+          reinterpret_cast<RequestedCall*>(requests_per_cq_[cq_idx].TryPop());
+      if (rc != nullptr) {
+        return Immediate(MatchResult{cq_idx, rc});
+      }
+    }
+    // No cq to take the request found; queue it on the slow list.
+    // We need to ensure that all the queues are empty.  We do this under
+    // the server mu_call_ lock to ensure that if something is added to
+    // an empty request queue, it will block until the call is actually
+    // added to the pending list.
+    RequestedCall* rc = nullptr;
+    size_t cq_idx = 0;
+    size_t loop_count;
+    {
+      MutexLock lock(&server_->mu_call_);
+      for (loop_count = 0; loop_count < requests_per_cq_.size(); loop_count++) {
+        cq_idx =
+            (start_request_queue_index + loop_count) % requests_per_cq_.size();
+        rc = reinterpret_cast<RequestedCall*>(requests_per_cq_[cq_idx].Pop());
+        if (rc != nullptr) {
+          break;
+        }
+      }
+      if (rc == nullptr) {
+        auto w = std::make_shared<ActivityWaiter>(
+            Activity::current()->MakeOwningWaker());
+        pending_.push(w);
+        return [w]() -> Poll<absl::StatusOr<MatchResult>> {
+          std::unique_ptr<absl::StatusOr<MatchResult>> r(
+              w->result.exchange(nullptr, std::memory_order_acq_rel));
+          if (r == nullptr) return Pending{};
+          return std::move(*r);
+        };
+      }
+    }
+    return Immediate(MatchResult{cq_idx, rc});
+  }
+
   Server* server() const override { return server_; }
 
  private:
   Server* const server_;
-  std::queue<CallData*> pending_;
+  struct ActivityWaiter {
+    explicit ActivityWaiter(Waker waker) : waker(std::move(waker)) {}
+    ~ActivityWaiter() { delete result.load(std::memory_order_acquire); }
+    void Finish(absl::StatusOr<MatchResult> r) {
+      result.store(new absl::StatusOr<MatchResult>(std::move(r)),
+                   std::memory_order_release);
+      waker.Wakeup();
+    }
+    Waker waker;
+    std::atomic<absl::StatusOr<MatchResult>*> result{nullptr};
+  };
+  using PendingCall = absl::variant<CallData*, std::shared_ptr<ActivityWaiter>>;
+  std::queue<PendingCall> pending_;
   std::vector<LockedMultiProducerSingleConsumerQueue> requests_per_cq_;
 };
 
@@ -371,7 +470,10 @@ class Server::AllocatingRequestMatcherBatch
 
   void MatchOrQueue(size_t /*start_request_queue_index*/,
                     CallData* calld) override {
-    if (server()->ShutdownRefOnRequest()) {
+    const bool still_running = server()->ShutdownRefOnRequest();
+    auto cleanup_ref =
+        absl::MakeCleanup([this] { server()->ShutdownUnrefOnRequest(); });
+    if (still_running) {
       BatchCallAllocation call_info = allocator_();
       GPR_ASSERT(server()->ValidateServerRequest(
                      cq(), static_cast<void*>(call_info.tag), nullptr,
@@ -384,7 +486,25 @@ class Server::AllocatingRequestMatcherBatch
     } else {
       calld->FailCallCreation();
     }
-    server()->ShutdownUnrefOnRequest();
+  }
+
+  ArenaPromise<absl::StatusOr<MatchResult>> MatchRequest(
+      size_t /*start_request_queue_index*/) override {
+    const bool still_running = server()->ShutdownRefOnRequest();
+    auto cleanup_ref =
+        absl::MakeCleanup([this] { server()->ShutdownUnrefOnRequest(); });
+    if (still_running) {
+      BatchCallAllocation call_info = allocator_();
+      GPR_ASSERT(server()->ValidateServerRequest(
+                     cq(), static_cast<void*>(call_info.tag), nullptr,
+                     nullptr) == GRPC_CALL_OK);
+      RequestedCall* rc = new RequestedCall(
+          static_cast<void*>(call_info.tag), call_info.cq, call_info.call,
+          call_info.initial_metadata, call_info.details);
+      return Immediate(MatchResult{cq_idx(), rc});
+    } else {
+      return Immediate(absl::InternalError("Server shutdown"));
+    }
   }
 
  private:
@@ -404,6 +524,8 @@ class Server::AllocatingRequestMatcherRegistered
 
   void MatchOrQueue(size_t /*start_request_queue_index*/,
                     CallData* calld) override {
+    auto cleanup_ref =
+        absl::MakeCleanup([this] { server()->ShutdownUnrefOnRequest(); });
     if (server()->ShutdownRefOnRequest()) {
       RegisteredCallAllocation call_info = allocator_();
       GPR_ASSERT(server()->ValidateServerRequest(
@@ -418,7 +540,26 @@ class Server::AllocatingRequestMatcherRegistered
     } else {
       calld->FailCallCreation();
     }
-    server()->ShutdownUnrefOnRequest();
+  }
+
+  ArenaPromise<absl::StatusOr<MatchResult>> MatchRequest(
+      size_t /*start_request_queue_index*/) override {
+    const bool still_running = server()->ShutdownRefOnRequest();
+    auto cleanup_ref =
+        absl::MakeCleanup([this] { server()->ShutdownUnrefOnRequest(); });
+    if (still_running) {
+      RegisteredCallAllocation call_info = allocator_();
+      GPR_ASSERT(server()->ValidateServerRequest(
+                     cq(), call_info.tag, call_info.optional_payload,
+                     registered_method_) == GRPC_CALL_OK);
+      RequestedCall* rc =
+          new RequestedCall(call_info.tag, call_info.cq, call_info.call,
+                            call_info.initial_metadata, registered_method_,
+                            call_info.deadline, call_info.optional_payload);
+      return Immediate(MatchResult{cq_idx(), rc});
+    } else {
+      return Immediate(absl::InternalError("Server shutdown"));
+    }
   }
 
  private:
@@ -493,7 +634,7 @@ class ChannelBroadcaster {
 
 const grpc_channel_filter Server::kServerTopFilter = {
     Server::CallData::StartTransportStreamOpBatch,
-    nullptr,
+    Server::ChannelData::MakeCallPromise,
     grpc_channel_next_op,
     sizeof(Server::CallData),
     Server::CallData::InitCallElement,
@@ -1100,14 +1241,119 @@ void Server::ChannelData::AcceptStream(void* arg, grpc_transport* /*transport*/,
   args.send_deadline = Timestamp::InfFuture();
   grpc_call* call;
   grpc_error_handle error = grpc_call_create(&args, &call);
-  grpc_call_element* elem =
-      grpc_call_stack_element(grpc_call_get_call_stack(call), 0);
-  auto* calld = static_cast<Server::CallData*>(elem->call_data);
-  if (!error.ok()) {
-    calld->FailCallCreation();
+  grpc_call_stack* call_stack = grpc_call_get_call_stack(call);
+  if (call_stack == nullptr) {  // Promise based calls do not have a call stack
+    GPR_ASSERT(error.ok());
+    GPR_ASSERT(IsPromiseBasedServerCallEnabled());
     return;
-  }
-  calld->Start(elem);
+  } else {
+    grpc_call_element* elem = grpc_call_stack_element(call_stack, 0);
+    auto* calld = static_cast<Server::CallData*>(elem->call_data);
+    if (!error.ok()) {
+      calld->FailCallCreation();
+      return;
+    }
+    calld->Start(elem);
+  }
+}
+
+ArenaPromise<ServerMetadataHandle> Server::ChannelData::MakeCallPromise(
+    grpc_channel_element* elem, CallArgs call_args, NextPromiseFactory) {
+  auto* chand = static_cast<Server::ChannelData*>(elem->channel_data);
+  auto* server = chand->server_.get();
+  if (server->ShutdownCalled()) {
+    return [] {
+      return ServerMetadataFromStatus(absl::InternalError("Server shutdown"));
+    };
+  }
+  absl::optional<Slice> path =
+      call_args.client_initial_metadata->Take(HttpPathMetadata());
+  if (!path.has_value()) {
+    return [] {
+      return ServerMetadataFromStatus(
+          absl::InternalError("Missing :path header"));
+    };
+  }
+  auto host_ptr =
+      call_args.client_initial_metadata->get_pointer(HttpAuthorityMetadata());
+  if (host_ptr == nullptr) {
+    return [] {
+      return ServerMetadataFromStatus(
+          absl::InternalError("Missing :authority header"));
+    };
+  }
+  // TODO(ctiller): deadline handling
+  Timestamp deadline = Timestamp::InfFuture();
+  // Find request matcher.
+  RequestMatcherInterface* matcher;
+  ChannelRegisteredMethod* rm =
+      chand->GetRegisteredMethod(host_ptr->c_slice(), path->c_slice());
+  ArenaPromise<absl::StatusOr<NextResult<MessageHandle>>>
+      maybe_read_first_message([] { return NextResult<MessageHandle>(); });
+  if (rm != nullptr) {
+    matcher = rm->server_registered_method->matcher.get();
+    switch (rm->server_registered_method->payload_handling) {
+      case GRPC_SRM_PAYLOAD_NONE:
+        break;
+      case GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER:
+        maybe_read_first_message =
+            Map(call_args.client_to_server_messages->Next(),
+                [](NextResult<MessageHandle> msg)
+                    -> absl::StatusOr<NextResult<MessageHandle>> {
+                  return std::move(msg);
+                });
+    }
+  } else {
+    matcher = server->unregistered_request_matcher_.get();
+  }
+  return TrySeq(
+      TryJoin(matcher->MatchRequest(chand->cq_idx()),
+              std::move(maybe_read_first_message)),
+      [path = std::move(*path), host = std::move(*host_ptr), deadline, server,
+       call_args = std::move(call_args)](
+          std::tuple<RequestMatcherInterface::MatchResult,
+                     NextResult<MessageHandle>>
+              match_result_and_payload) mutable {
+        auto& mr = std::get<0>(match_result_and_payload);
+        auto& payload = std::get<1>(match_result_and_payload);
+        auto* rc = mr.requested_call;
+        auto* cq_for_new_request = server->cqs_[mr.cq_idx];
+        switch (rc->type) {
+          case RequestedCall::Type::BATCH_CALL:
+            GPR_ASSERT(!payload.has_value());
+            rc->data.batch.details->host = CSliceRef(host.c_slice());
+            rc->data.batch.details->method = CSliceRef(path.c_slice());
+            rc->data.batch.details->deadline =
+                deadline.as_timespec(GPR_CLOCK_MONOTONIC);
+            break;
+          case RequestedCall::Type::REGISTERED_CALL:
+            *rc->data.registered.deadline =
+                deadline.as_timespec(GPR_CLOCK_MONOTONIC);
+            if (rc->data.registered.optional_payload != nullptr) {
+              if (payload.has_value()) {
+                auto* sb = payload.value()->payload()->c_slice_buffer();
+                *rc->data.registered.optional_payload =
+                    grpc_raw_byte_buffer_create(sb->slices, sb->count);
+              } else {
+                *rc->data.registered.optional_payload = nullptr;
+              }
+            }
+            break;
+          default:
+            GPR_UNREACHABLE_CODE(abort());
+        }
+        return GetContext<CallContext>()
+            ->server_call_context()
+            ->MakeTopOfServerCallPromise(
+                std::move(call_args), rc->cq_bound_to_call,
+                rc->initial_metadata,
+                [rc, cq_for_new_request](grpc_call* call) {
+                  *rc->call = call;
+                  grpc_cq_end_op(cq_for_new_request, rc->tag, absl::OkStatus(),
+                                 Server::DoneRequestEvent, rc, &rc->completion,
+                                 true);
+                });
+      });
 }
 
 void Server::ChannelData::FinishDestroy(void* arg,
@@ -1273,6 +1519,7 @@ void Server::CallData::KillZombie() {
   ExecCtx::Run(DEBUG_LOCATION, &kill_zombie_closure_, absl::OkStatus());
 }
 
+// If this changes, change MakeCallPromise too.
 void Server::CallData::StartNewRpc(grpc_call_element* elem) {
   auto* chand = static_cast<ChannelData*>(elem->channel_data);
   if (server_->ShutdownCalled()) {
@@ -1361,7 +1608,6 @@ void Server::CallData::RecvInitialMetadataReady(void* arg,
     // do nothing
   } else if (error.ok()) {
     // Pass the error reference to calld->recv_initial_metadata_error
-    grpc_error_handle src_error = error;
     error = absl::UnknownError("Missing :authority or :path");
     calld->recv_initial_metadata_error_ = error;
   }

data/src/core/lib/surface/server.h

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_LIB_SURFACE_SERVER_H
-#define GRPC_CORE_LIB_SURFACE_SERVER_H
+#ifndef GRPC_SRC_CORE_LIB_SURFACE_SERVER_H
+#define GRPC_SRC_CORE_LIB_SURFACE_SERVER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -56,6 +56,7 @@
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
+#include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/completion_queue.h"
@@ -236,6 +237,8 @@ class Server : public InternallyRefCounted<Server>,
     static grpc_error_handle InitChannelElement(
         grpc_channel_element* elem, grpc_channel_element_args* args);
     static void DestroyChannelElement(grpc_channel_element* elem);
+    static ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+        grpc_channel_element* elem, CallArgs call_args, NextPromiseFactory);
 
    private:
     class ConnectivityWatcher;
@@ -521,4 +524,4 @@ struct grpc_server_config_fetcher {
   virtual grpc_pollset_set* interested_parties() = 0;
 };
 
-#endif  // GRPC_CORE_LIB_SURFACE_SERVER_H
+#endif  // GRPC_SRC_CORE_LIB_SURFACE_SERVER_H

data/src/core/lib/surface/validate_metadata.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_LIB_SURFACE_VALIDATE_METADATA_H
-#define GRPC_CORE_LIB_SURFACE_VALIDATE_METADATA_H
+#ifndef GRPC_SRC_CORE_LIB_SURFACE_VALIDATE_METADATA_H
+#define GRPC_SRC_CORE_LIB_SURFACE_VALIDATE_METADATA_H
 
 #include <grpc/support/port_platform.h>
 
@@ -45,4 +45,4 @@ inline int grpc_is_refcounted_slice_binary_header(const grpc_slice& slice) {
                                    slice.data.refcounted.length);
 }
 
-#endif  // GRPC_CORE_LIB_SURFACE_VALIDATE_METADATA_H
+#endif  // GRPC_SRC_CORE_LIB_SURFACE_VALIDATE_METADATA_H

data/src/core/lib/surface/version.cc

@@ -23,6 +23,6 @@
 
 #include <grpc/grpc.h>
 
-const char* grpc_version_string(void) { return "30.0.0"; }
+const char* grpc_version_string(void) { return "30.1.0"; }
 
-const char* grpc_g_stands_for(void) { return "gribkoff"; }
+const char* grpc_g_stands_for(void) { return "glockenspiel"; }

data/src/core/lib/transport/bdp_estimator.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_LIB_TRANSPORT_BDP_ESTIMATOR_H
-#define GRPC_CORE_LIB_TRANSPORT_BDP_ESTIMATOR_H
+#ifndef GRPC_SRC_CORE_LIB_TRANSPORT_BDP_ESTIMATOR_H
+#define GRPC_SRC_CORE_LIB_TRANSPORT_BDP_ESTIMATOR_H
 
 #include <grpc/support/port_platform.h>
 
@@ -90,4 +90,4 @@ class BdpEstimator {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_TRANSPORT_BDP_ESTIMATOR_H
+#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_BDP_ESTIMATOR_H

data/src/core/lib/transport/connectivity_state.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_LIB_TRANSPORT_CONNECTIVITY_STATE_H
-#define GRPC_CORE_LIB_TRANSPORT_CONNECTIVITY_STATE_H
+#ifndef GRPC_SRC_CORE_LIB_TRANSPORT_CONNECTIVITY_STATE_H
+#define GRPC_SRC_CORE_LIB_TRANSPORT_CONNECTIVITY_STATE_H
 
 #include <grpc/support/port_platform.h>
 
@@ -141,4 +141,4 @@ class ConnectivityStateTracker {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_TRANSPORT_CONNECTIVITY_STATE_H
+#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_CONNECTIVITY_STATE_H

data/src/core/lib/transport/error_utils.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_LIB_TRANSPORT_ERROR_UTILS_H
-#define GRPC_CORE_LIB_TRANSPORT_ERROR_UTILS_H
+#ifndef GRPC_SRC_CORE_LIB_TRANSPORT_ERROR_UTILS_H
+#define GRPC_SRC_CORE_LIB_TRANSPORT_ERROR_UTILS_H
 
 #include <grpc/support/port_platform.h>
 
@@ -60,4 +60,4 @@ grpc_error_handle absl_status_to_grpc_error(absl::Status status);
 /// absl::OkStatus() or absl::CancelledError()
 bool grpc_error_has_clear_grpc_status(grpc_error_handle error);
 
-#endif  // GRPC_CORE_LIB_TRANSPORT_ERROR_UTILS_H
+#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_ERROR_UTILS_H

data/src/core/lib/transport/handshaker.cc

@@ -22,12 +22,14 @@
 
 #include <inttypes.h>
 
+#include <initializer_list>
 #include <string>
 #include <utility>
 
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 
+#include <grpc/byte_buffer.h>
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/grpc.h>
 #include <grpc/slice_buffer.h>
@@ -38,6 +40,7 @@
 #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/iomgr/event_engine_shims/endpoint.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 
 namespace grpc_core {
@@ -189,6 +192,14 @@ void HandshakeManager::DoHandshake(grpc_endpoint* endpoint,
         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;

data/src/core/lib/transport/handshaker.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_LIB_TRANSPORT_HANDSHAKER_H
-#define GRPC_CORE_LIB_TRANSPORT_HANDSHAKER_H
+#ifndef GRPC_SRC_CORE_LIB_TRANSPORT_HANDSHAKER_H
+#define GRPC_SRC_CORE_LIB_TRANSPORT_HANDSHAKER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -75,7 +75,7 @@ struct HandshakerArgs {
   // individual handshakers.
   void* user_data = nullptr;
   // Deadline associated with the handshake.
-  // TODO(anramach): Move this out of handshake args after event engine
+  // TODO(anramach): Move this out of handshake args after EventEngine
   // is the default.
   Timestamp deadline;
 };
@@ -169,4 +169,4 @@ typedef grpc_core::Handshaker grpc_handshaker;
 void grpc_handshake_manager_add(grpc_handshake_manager* mgr,
                                 grpc_handshaker* handshaker);
 
-#endif  // GRPC_CORE_LIB_TRANSPORT_HANDSHAKER_H
+#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_HANDSHAKER_H

data/src/core/lib/transport/handshaker_factory.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_LIB_TRANSPORT_HANDSHAKER_FACTORY_H
-#define GRPC_CORE_LIB_TRANSPORT_HANDSHAKER_FACTORY_H
+#ifndef GRPC_SRC_CORE_LIB_TRANSPORT_HANDSHAKER_FACTORY_H
+#define GRPC_SRC_CORE_LIB_TRANSPORT_HANDSHAKER_FACTORY_H
 
 #include <grpc/support/port_platform.h>
 
@@ -71,4 +71,4 @@ class HandshakerFactory {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_TRANSPORT_HANDSHAKER_FACTORY_H
+#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_HANDSHAKER_FACTORY_H

data/src/core/lib/transport/handshaker_registry.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_LIB_TRANSPORT_HANDSHAKER_REGISTRY_H
-#define GRPC_CORE_LIB_TRANSPORT_HANDSHAKER_REGISTRY_H
+#ifndef GRPC_SRC_CORE_LIB_TRANSPORT_HANDSHAKER_REGISTRY_H
+#define GRPC_SRC_CORE_LIB_TRANSPORT_HANDSHAKER_REGISTRY_H
 
 #include <grpc/support/port_platform.h>
 
@@ -66,4 +66,4 @@ class HandshakerRegistry {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_TRANSPORT_HANDSHAKER_REGISTRY_H
+#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_HANDSHAKER_REGISTRY_H

data/src/core/lib/transport/http2_errors.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_LIB_TRANSPORT_HTTP2_ERRORS_H
-#define GRPC_CORE_LIB_TRANSPORT_HTTP2_ERRORS_H
+#ifndef GRPC_SRC_CORE_LIB_TRANSPORT_HTTP2_ERRORS_H
+#define GRPC_SRC_CORE_LIB_TRANSPORT_HTTP2_ERRORS_H
 
 // error codes for RST_STREAM from http2 draft 14 section 7
 typedef enum {
@@ -38,4 +38,4 @@ typedef enum {
   GRPC_HTTP2__ERROR_DO_NOT_USE = -1
 } grpc_http2_error_code;
 
-#endif  // GRPC_CORE_LIB_TRANSPORT_HTTP2_ERRORS_H
+#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_HTTP2_ERRORS_H

data/src/core/lib/transport/http_connect_handshaker.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_LIB_TRANSPORT_HTTP_CONNECT_HANDSHAKER_H
-#define GRPC_CORE_LIB_TRANSPORT_HTTP_CONNECT_HANDSHAKER_H
+#ifndef GRPC_SRC_CORE_LIB_TRANSPORT_HTTP_CONNECT_HANDSHAKER_H
+#define GRPC_SRC_CORE_LIB_TRANSPORT_HTTP_CONNECT_HANDSHAKER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -39,4 +39,4 @@ void RegisterHttpConnectHandshaker(CoreConfiguration::Builder* builder);
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_TRANSPORT_HTTP_CONNECT_HANDSHAKER_H
+#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_HTTP_CONNECT_HANDSHAKER_H