grpc 1.63.0 → 1.65.2

data/src/core/ext/transport/chttp2/transport/stream_lists.cc

@@ -16,9 +16,10 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
+#include "absl/log/check.h"
 
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
@@ -43,8 +44,6 @@ static const char* stream_list_id_string(grpc_chttp2_stream_list_id id) {
   GPR_UNREACHABLE_CODE(return "unknown");
 }
 
-grpc_core::TraceFlag grpc_trace_http2_stream_state(false, "http2_stream_state");
-
 // core list management
 
 static bool stream_list_empty(grpc_chttp2_transport* t,
@@ -58,7 +57,7 @@ static bool stream_list_pop(grpc_chttp2_transport* t,
   grpc_chttp2_stream* s = t->lists[id].head;
   if (s) {
     grpc_chttp2_stream* new_head = s->links[id].next;
-    GPR_ASSERT(s->included.is_set(id));
+    CHECK(s->included.is_set(id));
     if (new_head) {
       t->lists[id].head = new_head;
       new_head->links[id].prev = nullptr;
@@ -69,7 +68,7 @@ static bool stream_list_pop(grpc_chttp2_transport* t,
     s->included.clear(id);
   }
   *stream = s;
-  if (s && GRPC_TRACE_FLAG_ENABLED(grpc_trace_http2_stream_state)) {
+  if (s && GRPC_TRACE_FLAG_ENABLED(http2_stream_state)) {
     gpr_log(GPR_INFO, "%p[%d][%s]: pop from %s", t, s->id,
             t->is_client ? "cli" : "svr", stream_list_id_string(id));
   }
@@ -78,12 +77,12 @@ static bool stream_list_pop(grpc_chttp2_transport* t,
 
 static void stream_list_remove(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
                                grpc_chttp2_stream_list_id id) {
-  GPR_ASSERT(s->included.is_set(id));
+  CHECK(s->included.is_set(id));
   s->included.clear(id);
   if (s->links[id].prev) {
     s->links[id].prev->links[id].next = s->links[id].next;
   } else {
-    GPR_ASSERT(t->lists[id].head == s);
+    CHECK(t->lists[id].head == s);
     t->lists[id].head = s->links[id].next;
   }
   if (s->links[id].next) {
@@ -91,7 +90,7 @@ static void stream_list_remove(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
   } else {
     t->lists[id].tail = s->links[id].prev;
   }
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_http2_stream_state)) {
+  if (GRPC_TRACE_FLAG_ENABLED(http2_stream_state)) {
     gpr_log(GPR_INFO, "%p[%d][%s]: remove from %s", t, s->id,
             t->is_client ? "cli" : "svr", stream_list_id_string(id));
   }
@@ -112,7 +111,7 @@ static void stream_list_add_tail(grpc_chttp2_transport* t,
                                  grpc_chttp2_stream* s,
                                  grpc_chttp2_stream_list_id id) {
   grpc_chttp2_stream* old_tail;
-  GPR_ASSERT(!s->included.is_set(id));
+  CHECK(!s->included.is_set(id));
   old_tail = t->lists[id].tail;
   s->links[id].next = nullptr;
   s->links[id].prev = old_tail;
@@ -123,7 +122,7 @@ static void stream_list_add_tail(grpc_chttp2_transport* t,
   }
   t->lists[id].tail = s;
   s->included.set(id);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_http2_stream_state)) {
+  if (GRPC_TRACE_FLAG_ENABLED(http2_stream_state)) {
     gpr_log(GPR_INFO, "%p[%d][%s]: add to %s", t, s->id,
             t->is_client ? "cli" : "svr", stream_list_id_string(id));
   }
@@ -142,7 +141,7 @@ static bool stream_list_add(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
 
 bool grpc_chttp2_list_add_writable_stream(grpc_chttp2_transport* t,
                                           grpc_chttp2_stream* s) {
-  GPR_ASSERT(s->id != 0);
+  CHECK_NE(s->id, 0u);
   return stream_list_add(t, s, GRPC_CHTTP2_LIST_WRITABLE);
 }
 

data/src/core/ext/transport/chttp2/transport/varint.cc

@@ -16,12 +16,12 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/ext/transport/chttp2/transport/varint.h"
 
 #include "absl/base/attributes.h"
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_core {
 
 size_t VarintLength(size_t tail_value) {

data/src/core/ext/transport/chttp2/transport/varint.h

@@ -19,12 +19,13 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_VARINT_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_VARINT_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 #include <stdlib.h>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 // Helpers for hpack varint encoding
 
@@ -50,7 +51,7 @@ class VarintWriter {
   explicit VarintWriter(size_t value)
       : value_(value),
         length_(value < kMaxInPrefix ? 1 : VarintLength(value - kMaxInPrefix)) {
-    GPR_ASSERT(value <= UINT32_MAX);
+    CHECK(value <= UINT32_MAX);
   }
 
   size_t value() const { return value_; }

data/src/core/ext/transport/chttp2/transport/write_size_policy.cc

@@ -12,20 +12,21 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/ext/transport/chttp2/transport/write_size_policy.h"
 
 #include <algorithm>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_core {
 
 size_t Chttp2WriteSizePolicy::WriteTargetSize() { return current_target_; }
 
 void Chttp2WriteSizePolicy::BeginWrite(size_t size) {
-  GPR_ASSERT(experiment_start_time_ == Timestamp::InfFuture());
+  CHECK(experiment_start_time_ == Timestamp::InfFuture());
   if (size < current_target_ * 7 / 10) {
     // If we were trending fast but stopped getting enough data to verify, then
     // reset back to the default state.

data/src/core/ext/transport/chttp2/transport/write_size_policy.h

@@ -15,11 +15,11 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_WRITE_SIZE_POLICY_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_WRITE_SIZE_POLICY_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 #include <stdint.h>
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/gprpp/time.h"
 
 namespace grpc_core {

data/src/core/ext/transport/chttp2/transport/writing.cc

@@ -16,8 +16,6 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <inttypes.h>
 #include <stddef.h>
 
@@ -28,14 +26,17 @@
 #include <utility>
 
 #include "absl/container/flat_hash_map.h"
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/types/optional.h"
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
+#include "src/core/channelz/channelz.h"
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
 #include "src/core/ext/transport/chttp2/transport/context_list_entry.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
@@ -46,20 +47,14 @@
 #include "src/core/ext/transport/chttp2/transport/frame_window_update.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
-#include "src/core/ext/transport/chttp2/transport/http_trace.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/ext/transport/chttp2/transport/max_concurrent_streams_policy.h"
 #include "src/core/ext/transport/chttp2/transport/ping_callbacks.h"
 #include "src/core/ext/transport/chttp2/transport/ping_rate_policy.h"
 #include "src/core/ext/transport/chttp2/transport/write_size_policy.h"
-#include "src/core/lib/channel/call_tracer.h"
-#include "src/core/lib/channel/channelz.h"
-#include "src/core/lib/debug/stats.h"
-#include "src/core/lib/debug/stats_data.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/match.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -73,6 +68,10 @@
 #include "src/core/lib/transport/http2_errors.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/telemetry/call_tracer.h"
+#include "src/core/telemetry/stats.h"
+#include "src/core/telemetry/stats_data.h"
+#include "src/core/util/useful.h"
 
 // IWYU pragma: no_include "src/core/lib/gprpp/orphanable.h"
 
@@ -133,10 +132,10 @@ static void maybe_initiate_ping(grpc_chttp2_transport* t) {
           t->channelz_socket->RecordKeepaliveSent();
         }
         grpc_core::global_stats().IncrementHttp2PingsSent();
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
-            GRPC_TRACE_FLAG_ENABLED(grpc_bdp_estimator_trace) ||
-            GRPC_TRACE_FLAG_ENABLED(grpc_keepalive_trace) ||
-            GRPC_TRACE_FLAG_ENABLED(grpc_ping_trace)) {
+        if (GRPC_TRACE_FLAG_ENABLED(http) ||
+            GRPC_TRACE_FLAG_ENABLED(bdp_estimator) ||
+            GRPC_TRACE_FLAG_ENABLED(http_keepalive) ||
+            GRPC_TRACE_FLAG_ENABLED(http2_ping)) {
           gpr_log(GPR_INFO, "%s[%p]: Ping %" PRIx64 " sent [%s]: %s",
                   t->is_client ? "CLIENT" : "SERVER", t, id,
                   std::string(t->peer_string.as_string_view()).c_str(),
@@ -145,10 +144,10 @@ static void maybe_initiate_ping(grpc_chttp2_transport* t) {
       },
       [t](grpc_core::Chttp2PingRatePolicy::TooManyRecentPings) {
         // need to receive something of substance before sending a ping again
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
-            GRPC_TRACE_FLAG_ENABLED(grpc_bdp_estimator_trace) ||
-            GRPC_TRACE_FLAG_ENABLED(grpc_keepalive_trace) ||
-            GRPC_TRACE_FLAG_ENABLED(grpc_ping_trace)) {
+        if (GRPC_TRACE_FLAG_ENABLED(http) ||
+            GRPC_TRACE_FLAG_ENABLED(bdp_estimator) ||
+            GRPC_TRACE_FLAG_ENABLED(http_keepalive) ||
+            GRPC_TRACE_FLAG_ENABLED(http2_ping)) {
           gpr_log(GPR_INFO,
                   "%s[%p]: Ping delayed [%s]: too many recent pings: %s",
                   t->is_client ? "CLIENT" : "SERVER", t,
@@ -158,10 +157,10 @@ static void maybe_initiate_ping(grpc_chttp2_transport* t) {
       },
       [t](grpc_core::Chttp2PingRatePolicy::TooSoon too_soon) {
         // not enough elapsed time between successive pings
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
-            GRPC_TRACE_FLAG_ENABLED(grpc_bdp_estimator_trace) ||
-            GRPC_TRACE_FLAG_ENABLED(grpc_keepalive_trace) ||
-            GRPC_TRACE_FLAG_ENABLED(grpc_ping_trace)) {
+        if (GRPC_TRACE_FLAG_ENABLED(http) ||
+            GRPC_TRACE_FLAG_ENABLED(bdp_estimator) ||
+            GRPC_TRACE_FLAG_ENABLED(http_keepalive) ||
+            GRPC_TRACE_FLAG_ENABLED(http2_ping)) {
           gpr_log(
               GPR_INFO,
               "%s[%p]: Ping delayed [%s]: not enough time elapsed since last "
@@ -207,7 +206,7 @@ static bool update_list(grpc_chttp2_transport* t, int64_t send_bytes,
 
 static void report_stall(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
                          const char* staller) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_flowctl_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(flowctl)) {
     gpr_log(
         GPR_DEBUG,
         "%s:%p stream %d moved to stalled list by %s. This is FULLY expected "
@@ -269,7 +268,7 @@ class WriteContext {
       grpc_core::Http2Frame frame(std::move(*update));
       Serialize(absl::Span<grpc_core::Http2Frame>(&frame, 1), t_->outbuf);
       if (t_->keepalive_timeout != grpc_core::Duration::Infinity()) {
-        GPR_ASSERT(
+        CHECK(
             t_->settings_ack_watchdog ==
             grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid);
         // We base settings timeout on keepalive timeout, but double it to allow
@@ -291,7 +290,7 @@ class WriteContext {
     // simple writes are queued to qbuf, and flushed here
     grpc_slice_buffer_move_into(&t_->qbuf, t_->outbuf.c_slice_buffer());
     t_->num_pending_induced_frames = 0;
-    GPR_ASSERT(t_->qbuf.count == 0);
+    CHECK_EQ(t_->qbuf.count, 0u);
   }
 
   void FlushWindowUpdates() {
@@ -562,14 +561,6 @@ class StreamWriteContext {
       grpc_chttp2_encode_data(s_->id, &s_->flow_controlled_buffer, 0, true,
                               &s_->stats.outgoing, t_->outbuf.c_slice_buffer());
     } else {
-      if (send_status_.has_value()) {
-        s_->send_trailing_metadata->Set(grpc_core::HttpStatusMetadata(),
-                                        *send_status_);
-      }
-      if (send_content_type_.has_value()) {
-        s_->send_trailing_metadata->Set(grpc_core::ContentTypeMetadata(),
-                                        *send_content_type_);
-      }
       t_->hpack_compressor.EncodeHeaders(
           grpc_core::HPackCompressor::EncodeHeaderOptions{
               s_->id, true, t_->settings.peer().allow_true_binary_metadata(),
@@ -589,15 +580,39 @@ class StreamWriteContext {
   bool stream_became_writable() { return stream_became_writable_; }
 
  private:
+  class TrailersOnlyMetadataEncoder {
+   public:
+    explicit TrailersOnlyMetadataEncoder(grpc_metadata_batch* trailing_md)
+        : trailing_md_(trailing_md) {}
+
+    template <typename Which, typename Value>
+    void Encode(Which which, Value value) {
+      if (Which::kTransferOnTrailersOnly) {
+        trailing_md_->Set(which, value);
+      }
+    }
+
+    template <typename Which>
+    void Encode(Which which, const grpc_core::Slice& value) {
+      if (Which::kTransferOnTrailersOnly) {
+        trailing_md_->Set(which, value.Ref());
+      }
+    }
+
+    // Non-grpc metadata should not be transferred.
+    void Encode(const grpc_core::Slice&, const grpc_core::Slice&) {}
+
+   private:
+    grpc_metadata_batch* trailing_md_;
+  };
+
   void ConvertInitialMetadataToTrailingMetadata() {
     GRPC_CHTTP2_IF_TRACING(
         gpr_log(GPR_INFO, "not sending initial_metadata (Trailers-Only)"));
-    // When sending Trailers-Only, we need to move the :status and
-    // content-type headers to the trailers.
-    send_status_ =
-        s_->send_initial_metadata->get(grpc_core::HttpStatusMetadata());
-    send_content_type_ =
-        s_->send_initial_metadata->get(grpc_core::ContentTypeMetadata());
+    // When sending Trailers-Only, we need to move metadata from headers to
+    // trailers.
+    TrailersOnlyMetadataEncoder encoder(s_->send_trailing_metadata);
+    s_->send_initial_metadata->Encode(&encoder);
   }
 
   void SentLastFrame() {
@@ -630,9 +645,6 @@ class StreamWriteContext {
   grpc_chttp2_transport* const t_;
   grpc_chttp2_stream* const s_;
   bool stream_became_writable_ = false;
-  absl::optional<uint32_t> send_status_;
-  absl::optional<grpc_core::ContentTypeMetadata::ValueType> send_content_type_ =
-      {};
 };
 }  // namespace
 
@@ -669,10 +681,10 @@ grpc_chttp2_begin_write_result grpc_chttp2_begin_write(
             grpc_core::GrpcHttp2GetCopyContextFn();
         if (copy_context_fn != nullptr &&
             grpc_core::GrpcHttp2GetWriteTimestampsCallback() != nullptr) {
-          t->cl->emplace_back(copy_context_fn(s->context),
-                              outbuf_relative_start_pos, num_stream_bytes,
-                              s->byte_counter, s->write_counter - 1,
-                              s->tcp_tracer);
+          t->context_list->emplace_back(copy_context_fn(s->arena),
+                                        outbuf_relative_start_pos,
+                                        num_stream_bytes, s->byte_counter,
+                                        s->write_counter - 1, s->tcp_tracer);
         }
       }
       outbuf_relative_start_pos += num_stream_bytes;
@@ -715,7 +727,7 @@ void grpc_chttp2_end_write(grpc_chttp2_transport* t, grpc_error_handle error) {
           grpc_core::ExecCtx exec_ctx;
           grpc_chttp2_ping_timeout(t);
         });
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_ping_trace) && id.has_value()) {
+    if (GRPC_TRACE_FLAG_ENABLED(http2_ping) && id.has_value()) {
       gpr_log(GPR_INFO,
               "%s[%p]: Set ping timeout timer of %s for ping id %" PRIx64,
               t->is_client ? "CLIENT" : "SERVER", t, timeout.ToString().c_str(),
@@ -727,8 +739,8 @@ void grpc_chttp2_end_write(grpc_chttp2_transport* t, grpc_error_handle error) {
         t->keepalive_ping_timeout_handle !=
             grpc_event_engine::experimental::EventEngine::TaskHandle::
                 kInvalid) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_ping_trace) ||
-          GRPC_TRACE_FLAG_ENABLED(grpc_keepalive_trace)) {
+      if (GRPC_TRACE_FLAG_ENABLED(http2_ping) ||
+          GRPC_TRACE_FLAG_ENABLED(http_keepalive)) {
         gpr_log(GPR_INFO, "%s[%p]: Set keepalive ping timeout timer of %s",
                 t->is_client ? "CLIENT" : "SERVER", t,
                 t->keepalive_timeout.ToString().c_str());

data/src/core/ext/transport/inproc/inproc_transport.cc

@@ -12,14 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/ext/transport/inproc/inproc_transport.h"
 
 #include <atomic>
 
+#include "absl/log/check.h"
+
 #include <grpc/grpc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/ext/transport/inproc/legacy_inproc_transport.h"
 #include "src/core/lib/config/core_configuration.h"
@@ -27,19 +28,30 @@
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/promise/try_seq.h"
+#include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/surface/channel_create.h"
-#include "src/core/lib/surface/server.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/server/server.h"
 
 namespace grpc_core {
 
 namespace {
-class InprocServerTransport final : public RefCounted<InprocServerTransport>,
-                                    public Transport,
-                                    public ServerTransport {
+class InprocClientTransport;
+
+class InprocServerTransport final : public ServerTransport {
  public:
-  void SetAcceptor(Acceptor* acceptor) override {
-    acceptor_ = acceptor;
+  explicit InprocServerTransport(const ChannelArgs& args)
+      : event_engine_(
+            args.GetObjectRef<grpc_event_engine::experimental::EventEngine>()),
+        call_arena_allocator_(MakeRefCounted<CallArenaAllocator>(
+            args.GetObject<ResourceQuota>()
+                ->memory_quota()
+                ->CreateMemoryAllocator("inproc_server"),
+            1024)) {}
+
+  void SetCallDestination(
+      RefCountedPtr<UnstartedCallDestination> unstarted_call_handler) override {
+    unstarted_call_handler_ = unstarted_call_handler;
     ConnectionState expect = ConnectionState::kInitial;
     state_.compare_exchange_strong(expect, ConnectionState::kReady,
                                    std::memory_order_acq_rel,
@@ -58,8 +70,8 @@ class InprocServerTransport final : public RefCounted<InprocServerTransport>,
   void SetPollset(grpc_stream*, grpc_pollset*) override {}
   void SetPollsetSet(grpc_stream*, grpc_pollset_set*) override {}
   void PerformOp(grpc_transport_op* op) override {
-    gpr_log(GPR_INFO, "inproc server op: %s",
-            grpc_transport_op_string(op).c_str());
+    GRPC_TRACE_LOG(inproc, INFO)
+        << "inproc server op: " << grpc_transport_op_string(op);
     if (op->start_connectivity_watch != nullptr) {
       MutexLock lock(&state_tracker_mu_);
       state_tracker_.AddWatcher(op->start_connectivity_watch_state,
@@ -73,7 +85,6 @@ class InprocServerTransport final : public RefCounted<InprocServerTransport>,
       Crash("set_accept_stream not supported on inproc transport");
     }
   }
-  grpc_endpoint* GetEndpoint() override { return nullptr; }
 
   void Disconnect(absl::Status error) {
     if (disconnecting_.exchange(true, std::memory_order_relaxed)) return;
@@ -84,7 +95,7 @@ class InprocServerTransport final : public RefCounted<InprocServerTransport>,
                             "inproc transport disconnected");
   }
 
-  absl::StatusOr<CallInitiator> AcceptCall(ClientMetadata& md) {
+  absl::StatusOr<CallInitiator> AcceptCall(ClientMetadataHandle md) {
     switch (state_.load(std::memory_order_acquire)) {
       case ConnectionState::kInitial:
         return absl::InternalError(
@@ -94,43 +105,54 @@ class InprocServerTransport final : public RefCounted<InprocServerTransport>,
       case ConnectionState::kReady:
         break;
     }
-    return acceptor_->CreateCall(md, acceptor_->CreateArena());
+    auto server_call = MakeCallPair(std::move(md), event_engine_.get(),
+                                    call_arena_allocator_->MakeArena());
+    unstarted_call_handler_->StartCall(std::move(server_call.handler));
+    return std::move(server_call.initiator);
   }
 
+  OrphanablePtr<InprocClientTransport> MakeClientTransport();
+
  private:
   enum class ConnectionState : uint8_t { kInitial, kReady, kDisconnected };
 
   std::atomic<ConnectionState> state_{ConnectionState::kInitial};
   std::atomic<bool> disconnecting_{false};
-  Acceptor* acceptor_;
+  RefCountedPtr<UnstartedCallDestination> unstarted_call_handler_;
   absl::Status disconnect_error_;
   Mutex state_tracker_mu_;
   ConnectivityStateTracker state_tracker_ ABSL_GUARDED_BY(state_tracker_mu_){
       "inproc_server_transport", GRPC_CHANNEL_CONNECTING};
+  const std::shared_ptr<grpc_event_engine::experimental::EventEngine>
+      event_engine_;
+  const RefCountedPtr<CallArenaAllocator> call_arena_allocator_;
 };
 
-class InprocClientTransport final : public Transport, public ClientTransport {
+class InprocClientTransport final : public ClientTransport {
  public:
-  void StartCall(CallHandler call_handler) override {
-    call_handler.SpawnGuarded(
+  explicit InprocClientTransport(
+      RefCountedPtr<InprocServerTransport> server_transport)
+      : server_transport_(std::move(server_transport)) {}
+
+  void StartCall(CallHandler child_call_handler) override {
+    child_call_handler.SpawnGuarded(
         "pull_initial_metadata",
-        TrySeq(call_handler.PullClientInitialMetadata(),
+        TrySeq(child_call_handler.PullClientInitialMetadata(),
                [server_transport = server_transport_,
-                call_handler](ClientMetadataHandle md) {
-                 auto call_initiator = server_transport->AcceptCall(*md);
-                 if (!call_initiator.ok()) return call_initiator.status();
-                 ForwardCall(call_handler, std::move(*call_initiator),
-                             std::move(md));
+                child_call_handler](ClientMetadataHandle md) {
+                 auto server_call_initiator =
+                     server_transport->AcceptCall(std::move(md));
+                 if (!server_call_initiator.ok()) {
+                   return server_call_initiator.status();
+                 }
+                 ForwardCall(child_call_handler,
+                             std::move(*server_call_initiator));
                  return absl::OkStatus();
                }));
   }
 
   void Orphan() override { delete this; }
 
-  OrphanablePtr<Transport> GetServerTransport() {
-    return OrphanablePtr<Transport>(server_transport_->Ref().release());
-  }
-
   FilterStackTransport* filter_stack_transport() override { return nullptr; }
   ClientTransport* client_transport() override { return this; }
   ServerTransport* server_transport() override { return nullptr; }
@@ -138,7 +160,6 @@ class InprocClientTransport final : public Transport, public ClientTransport {
   void SetPollset(grpc_stream*, grpc_pollset*) override {}
   void SetPollsetSet(grpc_stream*, grpc_pollset_set*) override {}
   void PerformOp(grpc_transport_op*) override { Crash("unimplemented"); }
-  grpc_endpoint* GetEndpoint() override { return nullptr; }
 
  private:
   ~InprocClientTransport() override {
@@ -146,18 +167,20 @@ class InprocClientTransport final : public Transport, public ClientTransport {
         absl::UnavailableError("Client transport closed"));
   }
 
-  RefCountedPtr<InprocServerTransport> server_transport_ =
-      MakeRefCounted<InprocServerTransport>();
+  const RefCountedPtr<InprocServerTransport> server_transport_;
 };
 
 bool UsePromiseBasedTransport() {
-  if (!IsPromiseBasedInprocTransportEnabled()) return false;
-  GPR_ASSERT(IsPromiseBasedClientCallEnabled());
-  GPR_ASSERT(IsPromiseBasedServerCallEnabled());
-  return true;
+  return IsPromiseBasedInprocTransportEnabled();
+}
+
+OrphanablePtr<InprocClientTransport>
+InprocServerTransport::MakeClientTransport() {
+  return MakeOrphanable<InprocClientTransport>(
+      RefAsSubclass<InprocServerTransport>());
 }
 
-OrphanablePtr<Channel> MakeLameChannel(absl::string_view why,
+RefCountedPtr<Channel> MakeLameChannel(absl::string_view why,
                                        absl::Status error) {
   gpr_log(GPR_ERROR, "%s: %s", std::string(why).c_str(),
           std::string(error.message()).c_str());
@@ -166,13 +189,13 @@ OrphanablePtr<Channel> MakeLameChannel(absl::string_view why,
   if (grpc_error_get_int(error, StatusIntProperty::kRpcStatus, &integer)) {
     status = static_cast<grpc_status_code>(integer);
   }
-  return OrphanablePtr<Channel>(Channel::FromC(grpc_lame_client_channel_create(
+  return RefCountedPtr<Channel>(Channel::FromC(grpc_lame_client_channel_create(
       nullptr, status, std::string(why).c_str())));
 }
 
-OrphanablePtr<Channel> MakeInprocChannel(Server* server,
+RefCountedPtr<Channel> MakeInprocChannel(Server* server,
                                          ChannelArgs client_channel_args) {
-  auto transports = MakeInProcessTransportPair();
+  auto transports = MakeInProcessTransportPair(server->channel_args());
   auto client_transport = std::move(transports.first);
   auto server_transport = std::move(transports.second);
   auto error =
@@ -197,9 +220,10 @@ OrphanablePtr<Channel> MakeInprocChannel(Server* server,
 }  // namespace
 
 std::pair<OrphanablePtr<Transport>, OrphanablePtr<Transport>>
-MakeInProcessTransportPair() {
-  auto client_transport = MakeOrphanable<InprocClientTransport>();
-  auto server_transport = client_transport->GetServerTransport();
+MakeInProcessTransportPair(const ChannelArgs& server_channel_args) {
+  auto server_transport =
+      MakeOrphanable<InprocServerTransport>(server_channel_args);
+  auto client_transport = server_transport->MakeClientTransport();
   return std::make_pair(std::move(client_transport),
                         std::move(server_transport));
 }

data/src/core/ext/transport/inproc/inproc_transport.h

@@ -15,9 +15,8 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_INPROC_INPROC_TRANSPORT_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_INPROC_INPROC_TRANSPORT_H
 
-#include <grpc/support/port_platform.h>
-
 #include <grpc/grpc.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/transport/transport.h"
@@ -26,12 +25,10 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
                                          const grpc_channel_args* args,
                                          void* reserved);
 
-extern grpc_core::TraceFlag grpc_inproc_trace;
-
 namespace grpc_core {
 
 std::pair<OrphanablePtr<Transport>, OrphanablePtr<Transport>>
-MakeInProcessTransportPair();
+MakeInProcessTransportPair(const ChannelArgs& server_channel_args);
 
 }