grpc 1.73.0 → 1.75.0

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

@@ -270,6 +270,8 @@ class ChannelInit {
       return *this;
     }
 
+    const UniqueTypeName& name() { return name_; }
+
    private:
     friend class ChannelInit;
     const UniqueTypeName name_;
@@ -322,6 +324,34 @@ class ChannelInit {
           .SkipV3();
     }
 
+    // Register a builder in the normal fused filter registration pass.
+    // This occurs first during channel build time.
+    // The FilterRegistration methods can be called to declaratively define
+    // properties of the filter being registered.
+    // TODO(ctiller): remove in favor of the version that does not mention
+    // grpc_channel_filter
+    void RegisterFusedFilter(grpc_channel_stack_type type, UniqueTypeName name,
+                             const grpc_channel_filter* filter,
+                             FilterAdder filter_adder = nullptr,
+                             SourceLocation registration_source = {});
+
+    void RegisterFusedFilter(grpc_channel_stack_type type,
+                             const grpc_channel_filter* filter,
+                             SourceLocation registration_source = {}) {
+      CHECK(filter != nullptr);
+      RegisterFusedFilter(type, NameFromChannelFilter(filter), filter, nullptr,
+                          registration_source);
+    }
+
+    template <typename Filter>
+    void RegisterFusedFilter(grpc_channel_stack_type type,
+                             SourceLocation registration_source = {}) {
+      RegisterFusedFilter(
+          type, UniqueTypeNameFor<Filter>(), &Filter::kFilter,
+          [](InterceptionChainBuilder& builder) { builder.Add<Filter>(); },
+          registration_source);
+    }
+
     // Register a post processor for the builder.
     // These run after the main graph has been placed into the builder.
     // At most one filter per slot per channel stack type can be added.
@@ -341,6 +371,8 @@ class ChannelInit {
    private:
     std::vector<std::unique_ptr<FilterRegistration>>
         filters_[GRPC_NUM_CHANNEL_STACK_TYPES];
+    std::vector<std::unique_ptr<FilterRegistration>>
+        fused_filters_[GRPC_NUM_CHANNEL_STACK_TYPES];
     PostProcessor post_processors_[GRPC_NUM_CHANNEL_STACK_TYPES]
                                   [static_cast<int>(PostProcessorSlot::kCount)];
   };
@@ -382,17 +414,48 @@ class ChannelInit {
     Ordering ordering;
     bool CheckPredicates(const ChannelArgs& args) const;
   };
+
+  struct FilterNode {
+    const Filter* curr;
+    int next;
+  };
+
   struct StackConfig {
     std::vector<Filter> filters;
+    std::vector<Filter> fused_filters;
     std::vector<Filter> terminators;
     std::vector<PostProcessor> post_processors;
   };
 
   StackConfig stack_configs_[GRPC_NUM_CHANNEL_STACK_TYPES];
 
+  static std::tuple<std::vector<Filter>, std::vector<Filter>>
+  SortFilterRegistrationsByDependencies(
+      const std::vector<std::unique_ptr<FilterRegistration>>&
+          filter_registrations,
+      grpc_channel_stack_type type);
+
+  static std::vector<Filter> SortFusedFilterRegistrations(
+      const std::vector<std::unique_ptr<FilterRegistration>>&
+          filter_registrations);
+
+  template <bool is_terminal>
+  static std::vector<FilterNode> SelectFiltersByPredicate(
+      const std::vector<Filter>& filters, ChannelStackBuilder* builder);
+
+  static void MergeFilters(std::vector<FilterNode>& filter_list,
+                           const std::vector<Filter>& fused_filters);
+
+  static void AppendFiltersToBuilder(const std::vector<FilterNode>& filter_list,
+                                     ChannelStackBuilder* builder);
+
   static StackConfig BuildStackConfig(
-      const std::vector<std::unique_ptr<FilterRegistration>>& registrations,
+      const std::vector<std::unique_ptr<FilterRegistration>>&
+          filter_registrations,
+      const std::vector<std::unique_ptr<FilterRegistration>>&
+          fused_filter_registrations,
       PostProcessor* post_processors, grpc_channel_stack_type type);
+
   static void PrintChannelStackTrace(
       grpc_channel_stack_type type,
       const std::vector<std::unique_ptr<ChannelInit::FilterRegistration>>&

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

@@ -933,8 +933,7 @@ struct cq_is_finished_arg {
 class ExecCtxNext : public grpc_core::ExecCtx {
  public:
   explicit ExecCtxNext(void* arg)
-      : ExecCtx(0, GRPC_LATENT_SEE_METADATA("ExecCtx for CqNext")),
-        check_ready_to_finish_arg_(arg) {}
+      : ExecCtx(0), check_ready_to_finish_arg_(arg) {}
 
   bool CheckReadyToFinish() override {
     cq_is_finished_arg* a =
@@ -1181,8 +1180,7 @@ static void del_plucker(grpc_completion_queue* cq, void* tag,
 class ExecCtxPluck : public grpc_core::ExecCtx {
  public:
   explicit ExecCtxPluck(void* arg)
-      : ExecCtx(0, GRPC_LATENT_SEE_METADATA("ExecCtx for CqPluck")),
-        check_ready_to_finish_arg_(arg) {}
+      : ExecCtx(0), check_ready_to_finish_arg_(arg) {}
 
   bool CheckReadyToFinish() override {
     cq_is_finished_arg* a =

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

@@ -40,6 +40,7 @@
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
+#include "absl/strings/escaping.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "src/core/call/metadata_batch.h"
@@ -398,18 +399,26 @@ bool FilterStackCall::PrepareApplicationMetadata(size_t count,
       is_trailing ? &send_trailing_metadata_ : &send_initial_metadata_;
   for (size_t i = 0; i < count; i++) {
     grpc_metadata* md = &metadata[i];
-    if (!GRPC_LOG_IF_ERROR("validate_metadata",
-                           grpc_validate_header_key_is_legal(md->key))) {
+    if (auto status = grpc_validate_header_key_is_legal(md->key);
+        !status.ok()) {
+      LOG(ERROR) << "Metadata key '"
+                 << absl::CEscape(StringViewFromSlice(md->key))
+                 << "' is invalid: " << status;
       return false;
-    } else if (!grpc_is_binary_header_internal(md->key) &&
-               !GRPC_LOG_IF_ERROR(
-                   "validate_metadata",
-                   grpc_validate_header_nonbin_value_is_legal(md->value))) {
-      return false;
-    } else if (GRPC_SLICE_LENGTH(md->value) >= UINT32_MAX) {
+    }
+    if (!grpc_is_binary_header_internal(md->key)) {
+      if (auto status = grpc_validate_header_nonbin_value_is_legal(md->value);
+          !status.ok()) {
+        LOG(ERROR) << "Metadata value for key " << StringViewFromSlice(md->key)
+                   << " is invalid: " << status;
+        return false;
+      }
+    }
+    if (GRPC_SLICE_LENGTH(md->value) >= UINT32_MAX) {
       // HTTP2 hpack encoding has a maximum limit.
       return false;
-    } else if (grpc_slice_str_cmp(md->key, "content-length") == 0) {
+    }
+    if (grpc_slice_str_cmp(md->key, "content-length") == 0) {
       // Filter "content-length metadata"
       continue;
     }
@@ -737,7 +746,7 @@ void FilterStackCall::BatchControl::FinishBatch(grpc_error_handle error) {
 grpc_call_error FilterStackCall::StartBatch(const grpc_op* ops, size_t nops,
                                             void* notify_tag,
                                             bool is_notify_tag_closure) {
-  GRPC_LATENT_SEE_INNER_SCOPE("FilterStackCall::StartBatch");
+  GRPC_LATENT_SEE_SCOPE("FilterStackCall::StartBatch");
 
   size_t i;
   const grpc_op* op;

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

@@ -71,21 +71,12 @@ static bool g_shutting_down ABSL_GUARDED_BY(g_init_mu) = false;
 
 namespace grpc_core {
 void RegisterSecurityFilters(CoreConfiguration::Builder* builder) {
-  if (IsCallv3ClientAuthFilterEnabled()) {
-    builder->channel_init()
-        ->RegisterFilter<ClientAuthFilter>(GRPC_CLIENT_SUBCHANNEL)
-        .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
-    builder->channel_init()
-        ->RegisterFilter<ClientAuthFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
-        .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
-  } else {
-    builder->channel_init()
-        ->RegisterV2Filter<LegacyClientAuthFilter>(GRPC_CLIENT_SUBCHANNEL)
-        .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
-    builder->channel_init()
-        ->RegisterV2Filter<LegacyClientAuthFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
-        .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
-  }
+  builder->channel_init()
+      ->RegisterFilter<ClientAuthFilter>(GRPC_CLIENT_SUBCHANNEL)
+      .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
+  builder->channel_init()
+      ->RegisterFilter<ClientAuthFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
+      .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
   builder->channel_init()
       ->RegisterFilter<ServerAuthFilter>(GRPC_SERVER_CHANNEL)
       .IfHasChannelArg(GRPC_SERVER_CREDENTIALS_ARG);

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

@@ -63,7 +63,7 @@ namespace grpc_core {
 
 absl::StatusOr<RefCountedPtr<Channel>> LegacyChannel::Create(
     std::string target, ChannelArgs args,
-    grpc_channel_stack_type channel_stack_type) {
+    grpc_channel_stack_type channel_stack_type, const Blackboard* blackboard) {
   if (grpc_channel_stack_type_is_client(channel_stack_type)) {
     auto channel_args_mutator =
         grpc_channel_args_get_client_channel_creation_mutator();
@@ -113,6 +113,7 @@ absl::StatusOr<RefCountedPtr<Channel>> LegacyChannel::Create(
       grpc_channel_stack_type_string(channel_stack_type), channel_stack_type,
       args);
   builder.SetTarget(target.c_str());
+  builder.SetBlackboard(blackboard);
   if (!CoreConfiguration::Get().channel_init().CreateStack(&builder)) {
     return nullptr;
   }
@@ -161,10 +162,7 @@ LegacyChannel::LegacyChannel(bool is_client, std::string target,
     node = channelz_node()->RefAsSubclass<channelz::ChannelNode>();
   }
   *channel_stack_->on_destroy = [node = std::move(node)]() {
-    if (node != nullptr) {
-      node->AddTraceEvent(channelz::ChannelTrace::Severity::Info,
-                          grpc_slice_from_static_string("Channel destroyed"));
-    }
+    GRPC_CHANNELZ_LOG(node) << "Channel destroyed";
     ShutdownInternally();
   };
 }

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

@@ -29,6 +29,7 @@
 #include "absl/status/statusor.h"
 #include "src/core/call/call_arena_allocator.h"
 #include "src/core/client_channel/client_channel_filter.h"
+#include "src/core/filter/blackboard.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"  // IWYU pragma: keep
@@ -47,7 +48,8 @@ class LegacyChannel final : public Channel {
  public:
   static absl::StatusOr<RefCountedPtr<Channel>> Create(
       std::string target, ChannelArgs args,
-      grpc_channel_stack_type channel_stack_type);
+      grpc_channel_stack_type channel_stack_type,
+      const Blackboard* blackboard = nullptr);
 
   // Do not instantiate directly -- use Create() instead.
   LegacyChannel(bool is_client, std::string target,

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

@@ -22,6 +22,6 @@
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
-const char* grpc_version_string(void) { return "48.0.0"; }
+const char* grpc_version_string(void) { return "50.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "gradient"; }
+const char* grpc_g_stands_for(void) { return "gemini"; }

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

@@ -0,0 +1,110 @@
+// Copyright 2023 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/core/lib/transport/promise_endpoint.h"
+
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/slice_buffer.h>
+#include <grpc/slice_buffer.h>
+#include <grpc/support/port_platform.h>
+
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <utility>
+
+#include "absl/log/check.h"
+#include "absl/status/status.h"
+#include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/util/sync.h"
+
+namespace grpc_core {
+
+PromiseEndpoint::PromiseEndpoint(
+    std::unique_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
+        endpoint,
+    SliceBuffer already_received)
+    : endpoint_(std::move(endpoint)) {
+  CHECK_NE(endpoint_, nullptr);
+  read_state_->endpoint = endpoint_;
+  // TODO(ladynana): Replace this with `SliceBufferCast<>` when it is
+  // available.
+  grpc_slice_buffer_swap(read_state_->buffer.c_slice_buffer(),
+                         already_received.c_slice_buffer());
+}
+
+const grpc_event_engine::experimental::EventEngine::ResolvedAddress&
+PromiseEndpoint::GetPeerAddress() const {
+  return endpoint_->GetPeerAddress();
+}
+
+const grpc_event_engine::experimental::EventEngine::ResolvedAddress&
+PromiseEndpoint::GetLocalAddress() const {
+  return endpoint_->GetLocalAddress();
+}
+
+void PromiseEndpoint::ReadState::Complete(absl::Status status,
+                                          const size_t num_bytes_requested) {
+  GRPC_LATENT_SEE_SCOPE("PromiseEndpoint::ReadState::Complete");
+  while (true) {
+    if (!status.ok()) {
+      // Invalidates all previous reads.
+      pending_buffer.Clear();
+      buffer.Clear();
+      result = status;
+      auto w = std::move(waker);
+      complete.store(true, std::memory_order_release);
+      w.Wakeup();
+      return;
+    }
+    // Appends `pending_buffer` to `buffer`.
+    pending_buffer.MoveFirstNBytesIntoSliceBuffer(pending_buffer.Length(),
+                                                  buffer);
+    DCHECK(pending_buffer.Count() == 0u);
+    if (buffer.Length() < num_bytes_requested) {
+      GRPC_LATENT_SEE_SCOPE("PromiseEndpoint::ReadState::Continue");
+      // A further read is needed.
+      // Set read args with number of bytes needed as hint.
+      grpc_event_engine::experimental::EventEngine::Endpoint::ReadArgs
+          read_args;
+      read_args.set_read_hint_bytes(
+          static_cast<int64_t>(num_bytes_requested - buffer.Length()));
+      // If `Read()` returns true immediately, the callback will not be
+      // called. We still need to call our callback to pick up the result and
+      // maybe do further reads.
+      auto ep = endpoint.lock();
+      if (ep == nullptr) {
+        status = absl::UnavailableError("Endpoint closed during read.");
+        continue;
+      }
+      if (ep->Read(
+              [self = Ref(), num_bytes_requested](absl::Status status) {
+                ExecCtx exec_ctx;
+                self->Complete(std::move(status), num_bytes_requested);
+              },
+              &pending_buffer, std::move(read_args))) {
+        continue;
+      }
+      return;
+    }
+    result = status;
+    auto w = std::move(waker);
+    complete.store(true, std::memory_order_release);
+    w.Wakeup();
+    return;
+  }
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,307 @@
+// Copyright 2023 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_LIB_TRANSPORT_PROMISE_ENDPOINT_H
+#define GRPC_SRC_CORE_LIB_TRANSPORT_PROMISE_ENDPOINT_H
+
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/slice.h>
+#include <grpc/event_engine/slice_buffer.h>
+#include <grpc/slice_buffer.h>
+#include <grpc/support/port_platform.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <atomic>
+#include <cstring>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <utility>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/log/check.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "src/core/lib/event_engine/extensions/chaotic_good_extension.h"
+#include "src/core/lib/event_engine/query_extensions.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/cancel_callback.h"
+#include "src/core/lib/promise/if.h"
+#include "src/core/lib/promise/map.h"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/util/dump_args.h"
+#include "src/core/util/sync.h"
+
+namespace grpc_core {
+
+// Wrapper around event engine endpoint that provides a promise like API.
+class PromiseEndpoint {
+ public:
+  using WriteArgs =
+      grpc_event_engine::experimental::EventEngine::Endpoint::WriteArgs;
+
+  PromiseEndpoint(
+      std::unique_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
+          endpoint,
+      SliceBuffer already_received);
+  PromiseEndpoint() = default;
+  ~PromiseEndpoint() = default;
+  /// Prevent copying of PromiseEndpoint; moving is fine.
+  PromiseEndpoint(const PromiseEndpoint&) = delete;
+  PromiseEndpoint& operator=(const PromiseEndpoint&) = delete;
+  PromiseEndpoint(PromiseEndpoint&&) = default;
+  PromiseEndpoint& operator=(PromiseEndpoint&&) = default;
+
+  // Returns a promise that resolves to a `absl::Status` indicating the result
+  // of the write operation.
+  //
+  // Concurrent writes are not supported, which means callers should not call
+  // `Write()` before the previous write finishes. Doing that results in
+  // undefined behavior.
+  auto Write(SliceBuffer data, WriteArgs write_args) {
+    GRPC_LATENT_SEE_SCOPE("GRPC:Write");
+    // Start write and assert previous write finishes.
+    auto prev = write_state_->state.exchange(WriteState::kWriting,
+                                             std::memory_order_relaxed);
+    CHECK(prev == WriteState::kIdle);
+    bool completed;
+    if (data.Length() == 0) {
+      completed = true;
+    } else {
+      // TODO(ladynana): Replace this with `SliceBufferCast<>` when it is
+      // available.
+      grpc_slice_buffer_swap(write_state_->buffer.c_slice_buffer(),
+                             data.c_slice_buffer());
+      // If `Write()` returns true immediately, the callback will not be called.
+      // We still need to call our callback to pick up the result.
+      write_state_->waker = GetContext<Activity>()->MakeNonOwningWaker();
+      completed = endpoint_->Write(
+          [write_state = write_state_](absl::Status status) {
+            ExecCtx exec_ctx;
+            write_state->Complete(std::move(status));
+          },
+          &write_state_->buffer, std::move(write_args));
+      if (completed) write_state_->waker = Waker();
+    }
+    return If(
+        completed,
+        [this]() {
+          return [write_state = write_state_]() {
+            auto prev = write_state->state.exchange(WriteState::kIdle,
+                                                    std::memory_order_relaxed);
+            CHECK(prev == WriteState::kWriting);
+            return absl::OkStatus();
+          };
+        },
+        GRPC_LATENT_SEE_PROMISE(
+            "DelayedWrite", ([this]() {
+              return [write_state = write_state_]() -> Poll<absl::Status> {
+                // If current write isn't finished return `Pending()`, else
+                // return write result.
+                WriteState::State expected = WriteState::kWritten;
+                if (write_state->state.compare_exchange_strong(
+                        expected, WriteState::kIdle, std::memory_order_acquire,
+                        std::memory_order_relaxed)) {
+                  // State was Written, and we changed it to Idle. We can return
+                  // the result.
+                  return std::move(write_state->result);
+                }
+                // State was not Written; since we're polling it must be
+                // Writing. Assert that and return Pending.
+                CHECK(expected == WriteState::kWriting);
+                return Pending();
+              };
+            })));
+  }
+
+  // Returns a promise that resolves to `SliceBuffer` with
+  // `num_bytes` bytes.
+  //
+  // Concurrent reads are not supported, which means callers should not call
+  // `Read()` before the previous read finishes. Doing that results in
+  // undefined behavior.
+  auto Read(size_t num_bytes) {
+    GRPC_LATENT_SEE_SCOPE("GRPC:Read");
+    // Assert previous read finishes.
+    CHECK(!read_state_->complete.load(std::memory_order_relaxed));
+    // Should not have pending reads.
+    CHECK_EQ(read_state_->pending_buffer.Count(), 0u);
+    bool complete = true;
+    while (read_state_->buffer.Length() < num_bytes) {
+      GRPC_LATENT_SEE_SCOPE("GRPC:Read:Loop");
+      // Set read args with hinted bytes.
+      grpc_event_engine::experimental::EventEngine::Endpoint::ReadArgs
+          read_args;
+      read_args.set_read_hint_bytes(
+          static_cast<int64_t>(num_bytes - read_state_->buffer.Length()));
+      // If `Read()` returns true immediately, the callback will not be
+      // called.
+      read_state_->waker = GetContext<Activity>()->MakeNonOwningWaker();
+      if (endpoint_->Read(
+              [read_state = read_state_, num_bytes](absl::Status status) {
+                ExecCtx exec_ctx;
+                read_state->Complete(std::move(status), num_bytes);
+              },
+              &read_state_->pending_buffer, std::move(read_args))) {
+        read_state_->waker = Waker();
+        read_state_->pending_buffer.MoveFirstNBytesIntoSliceBuffer(
+            read_state_->pending_buffer.Length(), read_state_->buffer);
+        DCHECK_EQ(read_state_->pending_buffer.Count(), 0u);
+      } else {
+        complete = false;
+        break;
+      }
+    }
+    return If(
+        complete,
+        [this, num_bytes]() {
+          SliceBuffer ret;
+          grpc_slice_buffer_move_first_no_inline(
+              read_state_->buffer.c_slice_buffer(), num_bytes,
+              ret.c_slice_buffer());
+          return [ret = std::move(
+                      ret)]() mutable -> Poll<absl::StatusOr<SliceBuffer>> {
+            return std::move(ret);
+          };
+        },
+        GRPC_LATENT_SEE_PROMISE(
+            "DelayedRead", ([this, num_bytes]() {
+              return [read_state = read_state_,
+                      num_bytes]() -> Poll<absl::StatusOr<SliceBuffer>> {
+                if (!read_state->complete.load(std::memory_order_acquire)) {
+                  return Pending();
+                }
+                // If read succeeds, return `SliceBuffer` with `num_bytes`
+                // bytes.
+                if (read_state->result.ok()) {
+                  SliceBuffer ret;
+                  grpc_slice_buffer_move_first_no_inline(
+                      read_state->buffer.c_slice_buffer(), num_bytes,
+                      ret.c_slice_buffer());
+                  read_state->complete.store(false, std::memory_order_relaxed);
+                  return std::move(ret);
+                }
+                read_state->complete.store(false, std::memory_order_relaxed);
+                return std::move(read_state->result);
+              };
+            })));
+  }
+
+  // Returns a promise that resolves to `Slice` with at least
+  // `num_bytes` bytes which should be less than INT64_MAX bytes.
+  //
+  // Concurrent reads are not supported, which means callers should not call
+  // `ReadSlice()` before the previous read finishes. Doing that results in
+  // undefined behavior.
+  auto ReadSlice(size_t num_bytes) {
+    return Map(Read(num_bytes),
+               [](absl::StatusOr<SliceBuffer> buffer) -> absl::StatusOr<Slice> {
+                 if (!buffer.ok()) return buffer.status();
+                 return buffer->JoinIntoSlice();
+               });
+  }
+
+  // Returns a promise that resolves to a byte with type `uint8_t`.
+  auto ReadByte() {
+    return Map(ReadSlice(1),
+               [](absl::StatusOr<Slice> slice) -> absl::StatusOr<uint8_t> {
+                 if (!slice.ok()) return slice.status();
+                 return (*slice)[0];
+               });
+  }
+
+  // Enables RPC receive coalescing and alignment of memory holding received
+  // RPCs.
+  void EnforceRxMemoryAlignmentAndCoalescing() {
+    auto* chaotic_good_ext = grpc_event_engine::experimental::QueryExtension<
+        grpc_event_engine::experimental::ChaoticGoodExtension>(endpoint_.get());
+    if (chaotic_good_ext != nullptr) {
+      chaotic_good_ext->EnforceRxMemoryAlignment();
+      chaotic_good_ext->EnableRpcReceiveCoalescing();
+    }
+  }
+
+  const grpc_event_engine::experimental::EventEngine::ResolvedAddress&
+  GetPeerAddress() const;
+  const grpc_event_engine::experimental::EventEngine::ResolvedAddress&
+  GetLocalAddress() const;
+
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
+  GetEventEngineEndpoint() const {
+    return endpoint_;
+  }
+
+ private:
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
+      endpoint_;
+
+  struct ReadState : public RefCounted<ReadState> {
+    std::atomic<bool> complete{false};
+    // Read buffer used for storing successful reads given by
+    // `EventEngine::Endpoint` but not yet requested by the caller.
+    grpc_event_engine::experimental::SliceBuffer buffer;
+    // Buffer used to accept data from `EventEngine::Endpoint`.
+    // Every time after a successful read from `EventEngine::Endpoint`, the data
+    // in this buffer should be appended to `buffer`.
+    grpc_event_engine::experimental::SliceBuffer pending_buffer;
+    // Used for store the result from `EventEngine::Endpoint::Read()`.
+    absl::Status result;
+    Waker waker;
+    // Backing endpoint: we keep this on ReadState as reads will need to
+    // repeatedly read until the target size is hit, and we don't want to access
+    // the main object during this dance (indeed the main object may be
+    // deleted).
+    std::weak_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
+        endpoint;
+
+    void Complete(absl::Status status, size_t num_bytes_requested);
+  };
+
+  struct WriteState : public RefCounted<WriteState> {
+    enum State : uint8_t {
+      kIdle,     // Not writing.
+      kWriting,  // Write started, but not completed.
+      kWritten,  // Write completed.
+    };
+
+    std::atomic<State> state{kIdle};
+    // Write buffer used for `EventEngine::Endpoint::Write()` to ensure the
+    // memory behind the buffer is not lost.
+    grpc_event_engine::experimental::SliceBuffer buffer;
+    // Used for store the result from `EventEngine::Endpoint::Write()`.
+    absl::Status result;
+    Waker waker;
+
+    void Complete(absl::Status status) {
+      result = std::move(status);
+      auto w = std::move(waker);
+      auto prev = state.exchange(kWritten, std::memory_order_release);
+      // Previous state should be Writing. If we got anything else we've entered
+      // the callback path twice.
+      CHECK(prev == kWriting);
+      w.Wakeup();
+    }
+  };
+
+  RefCountedPtr<WriteState> write_state_ = MakeRefCounted<WriteState>();
+  RefCountedPtr<ReadState> read_state_ = MakeRefCounted<ReadState>();
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_PROMISE_ENDPOINT_H