grpc 1.70.1 → 1.72.0

data/src/core/{lib/transport → call}/call_spine.h

@@ -12,12 +12,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_SRC_CORE_LIB_TRANSPORT_CALL_SPINE_H
-#define GRPC_SRC_CORE_LIB_TRANSPORT_CALL_SPINE_H
+#ifndef GRPC_SRC_CORE_CALL_CALL_SPINE_H
+#define GRPC_SRC_CORE_CALL_CALL_SPINE_H
 
 #include <grpc/support/port_platform.h>
 
 #include "absl/log/check.h"
+#include "src/core/call/call_arena_allocator.h"
+#include "src/core/call/call_filters.h"
+#include "src/core/call/message.h"
+#include "src/core/call/metadata.h"
 #include "src/core/lib/promise/detail/status.h"
 #include "src/core/lib/promise/if.h"
 #include "src/core/lib/promise/latch.h"
@@ -27,10 +31,6 @@
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/promise/status_flag.h"
 #include "src/core/lib/promise/try_seq.h"
-#include "src/core/lib/transport/call_arena_allocator.h"
-#include "src/core/lib/transport/call_filters.h"
-#include "src/core/lib/transport/message.h"
-#include "src/core/lib/transport/metadata.h"
 #include "src/core/util/dual_ref_counted.h"
 
 namespace grpc_core {
@@ -106,7 +106,8 @@ class CallSpine final : public Party {
 
   void PushServerTrailingMetadata(ServerMetadataHandle md) {
     GRPC_TRACE_LOG(call_state, INFO)
-        << "[call_state] PushServerTrailingMetadata: " << md->DebugString();
+        << "[call_state] PushServerTrailingMetadata: " << this << " "
+        << md->DebugString();
     call_filters().PushServerTrailingMetadata(std::move(md));
   }
 
@@ -134,10 +135,10 @@ class CallSpine final : public Party {
     DCHECK(GetContext<Activity>() == this);
     using P = promise_detail::PromiseLike<Promise>;
     using ResultType = typename P::Result;
-    return Map(std::move(promise), [this](ResultType r) {
-      CancelIfFailed(r);
-      return r;
-    });
+    return Map(std::move(promise),
+               [self = RefAsSubclass<CallSpine>()](ResultType r) {
+                 self->CancelIfFailed(r);
+               });
   }
 
   template <typename StatusType>
@@ -200,27 +201,33 @@ class CallSpine final : public Party {
 
   // Spawned operations: these are callable from /outside/ the call; they spawn
   // an operation into the call and execute that operation.
+  //
+  // Server -> client operations are serialized in the order they are spawned.
+  // Client -> server operations are serialized in the order they are spawned.
+  //
+  // It's required that at most one thread call a server->client operation at a
+  // time, and likewise for client->server operations. There is no requirement
+  // that there be synchronization between the two directionalities.
+  //
+  // No ordering is given between the `Spawn` and the basic operations.
 
   void SpawnPushServerInitialMetadata(ServerMetadataHandle md) {
-    SpawnInfallible(
-        "push-server-initial-metadata",
+    server_to_client_serializer()->Spawn(
         [md = std::move(md), self = RefAsSubclass<CallSpine>()]() mutable {
           self->CancelIfFailed(self->PushServerInitialMetadata(std::move(md)));
         });
   }
 
-  auto SpawnPushServerToClientMessage(MessageHandle msg) {
-    return SpawnWaitable(
-        "push-message",
+  void SpawnPushServerToClientMessage(MessageHandle msg) {
+    server_to_client_serializer()->Spawn(
         [msg = std::move(msg), self = RefAsSubclass<CallSpine>()]() mutable {
           return self->CancelIfFails(
               self->PushServerToClientMessage(std::move(msg)));
         });
   }
 
-  auto SpawnPushClientToServerMessage(MessageHandle msg) {
-    return SpawnWaitable(
-        "push-message",
+  void SpawnPushClientToServerMessage(MessageHandle msg) {
+    client_to_server_serializer()->Spawn(
         [msg = std::move(msg), self = RefAsSubclass<CallSpine>()]() mutable {
           return self->CancelIfFails(
               self->PushClientToServerMessage(std::move(msg)));
@@ -228,19 +235,28 @@ class CallSpine final : public Party {
   }
 
   void SpawnFinishSends() {
-    SpawnInfallible("finish-sends", [self = RefAsSubclass<CallSpine>()]() {
+    client_to_server_serializer()->Spawn([self = RefAsSubclass<CallSpine>()]() {
       self->FinishSends();
       return Empty{};
     });
   }
 
   void SpawnPushServerTrailingMetadata(ServerMetadataHandle md) {
-    SpawnInfallible(
-        "push-server-trailing-metadata",
-        [md = std::move(md), self = RefAsSubclass<CallSpine>()]() mutable {
-          self->PushServerTrailingMetadata(std::move(md));
-          return Empty{};
-        });
+    if (md->get(GrpcCallWasCancelled()).value_or(false)) {
+      // Cancellation doesn't serialize with the rest of ops
+      SpawnInfallible(
+          "push-server-trailing-metadata",
+          [md = std::move(md), self = RefAsSubclass<CallSpine>()]() mutable {
+            self->PushServerTrailingMetadata(std::move(md));
+            return Empty{};
+          });
+    } else {
+      server_to_client_serializer()->Spawn(
+          [md = std::move(md), self = RefAsSubclass<CallSpine>()]() mutable {
+            self->PushServerTrailingMetadata(std::move(md));
+            return Empty{};
+          });
+    }
   }
 
   void SpawnCancel() {
@@ -274,11 +290,27 @@ class CallSpine final : public Party {
       : Party(std::move(arena)),
         call_filters_(std::move(client_initial_metadata)) {}
 
+  SpawnSerializer* client_to_server_serializer() {
+    if (client_to_server_serializer_ == nullptr) {
+      client_to_server_serializer_ = MakeSpawnSerializer();
+    }
+    return client_to_server_serializer_;
+  }
+
+  SpawnSerializer* server_to_client_serializer() {
+    if (server_to_client_serializer_ == nullptr) {
+      server_to_client_serializer_ = MakeSpawnSerializer();
+    }
+    return server_to_client_serializer_;
+  }
+
   // Call filters/pipes part of the spine
   CallFilters call_filters_;
   absl::AnyInvocable<void(bool)> on_done_{nullptr};
   // Call spines that should be cancelled if this spine is cancelled
   absl::InlinedVector<RefCountedPtr<CallSpine>, 3> child_calls_;
+  SpawnSerializer* client_to_server_serializer_ = nullptr;
+  SpawnSerializer* server_to_client_serializer_ = nullptr;
 };
 
 class CallHandler;
@@ -289,36 +321,56 @@ class CallInitiator {
 
   CallInitiator() = default;
   explicit CallInitiator(RefCountedPtr<CallSpine> spine)
-      : spine_(std::move(spine)) {}
+      : spine_(std::move(spine)) {
+    DCHECK_NE(spine_.get(), nullptr);
+  }
 
+  // Wrap a promise so that if it returns failure it automatically cancels
+  // the rest of the call.
+  // The resulting (returned) promise will resolve to Empty.
   template <typename Promise>
   auto CancelIfFails(Promise promise) {
+    DCHECK_NE(spine_.get(), nullptr);
     return spine_->CancelIfFails(std::move(promise));
   }
 
   auto PullServerInitialMetadata() {
+    DCHECK_NE(spine_.get(), nullptr);
     return spine_->PullServerInitialMetadata();
   }
 
   auto PushMessage(MessageHandle message) {
+    DCHECK_NE(spine_.get(), nullptr);
     return spine_->PushClientToServerMessage(std::move(message));
   }
 
-  auto SpawnPushMessage(MessageHandle message) {
-    return spine_->SpawnPushClientToServerMessage(std::move(message));
+  void SpawnPushMessage(MessageHandle message) {
+    DCHECK_NE(spine_.get(), nullptr);
+    spine_->SpawnPushClientToServerMessage(std::move(message));
   }
 
-  void FinishSends() { spine_->FinishSends(); }
+  void FinishSends() {
+    DCHECK_NE(spine_.get(), nullptr);
+    spine_->FinishSends();
+  }
 
-  void SpawnFinishSends() { spine_->SpawnFinishSends(); }
+  void SpawnFinishSends() {
+    DCHECK_NE(spine_.get(), nullptr);
+    spine_->SpawnFinishSends();
+  }
 
-  auto PullMessage() { return spine_->PullServerToClientMessage(); }
+  auto PullMessage() {
+    DCHECK_NE(spine_.get(), nullptr);
+    return spine_->PullServerToClientMessage();
+  }
 
   auto PullServerTrailingMetadata() {
+    DCHECK_NE(spine_.get(), nullptr);
     return spine_->PullServerTrailingMetadata();
   }
 
   void Cancel(absl::Status error) {
+    DCHECK_NE(spine_.get(), nullptr);
     CHECK(!error.ok());
     auto status = ServerMetadataFromStatus(error);
     status->Set(GrpcCallWasCancelled(), true);
@@ -326,47 +378,72 @@ class CallInitiator {
   }
 
   void SpawnCancel(absl::Status error) {
+    DCHECK_NE(spine_.get(), nullptr);
     CHECK(!error.ok());
     auto status = ServerMetadataFromStatus(error);
     status->Set(GrpcCallWasCancelled(), true);
     spine_->SpawnPushServerTrailingMetadata(std::move(status));
   }
 
-  void Cancel() { spine_->Cancel(); }
+  void Cancel() {
+    DCHECK_NE(spine_.get(), nullptr);
+    spine_->Cancel();
+  }
 
-  void SpawnCancel() { spine_->SpawnCancel(); }
+  void SpawnCancel() {
+    DCHECK_NE(spine_.get(), nullptr);
+    spine_->SpawnCancel();
+  }
 
   GRPC_MUST_USE_RESULT bool OnDone(absl::AnyInvocable<void(bool)> fn) {
+    DCHECK_NE(spine_.get(), nullptr);
     return spine_->OnDone(std::move(fn));
   }
 
+  template <typename Promise>
+  auto UntilCallCompletes(Promise promise) {
+    DCHECK_NE(spine_.get(), nullptr);
+    return spine_->UntilCallCompletes(std::move(promise));
+  }
+
   template <typename PromiseFactory>
   void SpawnGuarded(absl::string_view name, PromiseFactory promise_factory) {
+    DCHECK_NE(spine_.get(), nullptr);
     spine_->SpawnGuarded(name, std::move(promise_factory));
   }
 
   template <typename PromiseFactory>
   void SpawnGuardedUntilCallCompletes(absl::string_view name,
                                       PromiseFactory promise_factory) {
+    DCHECK_NE(spine_.get(), nullptr);
     spine_->SpawnGuardedUntilCallCompletes(name, std::move(promise_factory));
   }
 
   template <typename PromiseFactory>
   void SpawnInfallible(absl::string_view name, PromiseFactory promise_factory) {
+    DCHECK_NE(spine_.get(), nullptr);
     spine_->SpawnInfallible(name, std::move(promise_factory));
   }
 
   template <typename PromiseFactory>
   auto SpawnWaitable(absl::string_view name, PromiseFactory promise_factory) {
+    DCHECK_NE(spine_.get(), nullptr);
     return spine_->SpawnWaitable(name, std::move(promise_factory));
   }
 
   bool WasCancelledPushed() const {
+    DCHECK_NE(spine_.get(), nullptr);
     return spine_->call_filters().WasCancelledPushed();
   }
 
-  Arena* arena() { return spine_->arena(); }
-  Party* party() { return spine_.get(); }
+  Arena* arena() {
+    DCHECK_NE(spine_.get(), nullptr);
+    return spine_->arena();
+  }
+  Party* party() {
+    DCHECK_NE(spine_.get(), nullptr);
+    return spine_.get();
+  }
 
  private:
   friend class CallHandler;
@@ -404,6 +481,9 @@ class CallHandler {
     return spine_->OnDone(std::move(fn));
   }
 
+  // Wrap a promise so that if it returns failure it automatically cancels
+  // the rest of the call.
+  // The resulting (returned) promise will resolve to Empty.
   template <typename Promise>
   auto CancelIfFails(Promise promise) {
     return spine_->CancelIfFails(std::move(promise));
@@ -413,8 +493,8 @@ class CallHandler {
     return spine_->PushServerToClientMessage(std::move(message));
   }
 
-  auto SpawnPushMessage(MessageHandle message) {
-    return spine_->SpawnPushServerToClientMessage(std::move(message));
+  void SpawnPushMessage(MessageHandle message) {
+    spine_->SpawnPushServerToClientMessage(std::move(message));
   }
 
   auto PullMessage() { return spine_->PullClientToServerMessage(); }
@@ -425,6 +505,11 @@ class CallHandler {
     return spine_->call_filters().WasCancelledPushed();
   }
 
+  template <typename Promise>
+  auto UntilCallCompletes(Promise promise) {
+    return spine_->UntilCallCompletes(std::move(promise));
+  }
+
   template <typename PromiseFactory>
   void SpawnGuarded(absl::string_view name, PromiseFactory promise_factory,
                     DebugLocation whence = {}) {
@@ -556,4 +641,4 @@ void ForwardCall(
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_CALL_SPINE_H
+#endif  // GRPC_SRC_CORE_CALL_CALL_SPINE_H

data/src/core/{lib/transport → call}/call_state.cc

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "src/core/lib/transport/call_state.h"
+#include "src/core/call/call_state.h"
 
 namespace grpc_core {
 

data/src/core/{lib/transport → call}/call_state.h

@@ -12,12 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_SRC_CORE_LIB_TRANSPORT_CALL_STATE_H
-#define GRPC_SRC_CORE_LIB_TRANSPORT_CALL_STATE_H
+#ifndef GRPC_SRC_CORE_CALL_CALL_STATE_H
+#define GRPC_SRC_CORE_CALL_CALL_STATE_H
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/types/optional.h"
+#include <optional>
+
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/poll.h"
@@ -487,7 +488,7 @@ CallState::PollPullClientToServerMessageAvailable() {
     case ClientToServerPullState::kIdle:
       client_to_server_pull_state_ = ClientToServerPullState::kReading;
       client_to_server_pull_waiter_.Wake();
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case ClientToServerPullState::kReading:
       break;
     case ClientToServerPullState::kProcessingClientToServerMessage:
@@ -879,7 +880,7 @@ CallState::PollPullServerToClientMessageAvailable() {
       return server_to_client_pull_waiter_.pending();
     case ServerToClientPullState::kStarted:
       server_to_client_pull_state_ = ServerToClientPullState::kStartedReading;
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case ServerToClientPullState::kStartedReading:
       if (server_to_client_push_state_ ==
           ServerToClientPushState::kTrailersOnly) {
@@ -889,7 +890,7 @@ CallState::PollPullServerToClientMessageAvailable() {
     case ServerToClientPullState::kIdle:
       server_to_client_pull_state_ = ServerToClientPullState::kReading;
       server_to_client_pull_waiter_.Wake();
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case ServerToClientPullState::kReading:
       break;
     case ServerToClientPullState::kProcessingServerToClientMessage:
@@ -1038,7 +1039,7 @@ CallState::PollServerTrailingMetadataAvailable() {
               ServerTrailingMetadataState::kNotPushed) {
             break;  // Ready for processing
           }
-          ABSL_FALLTHROUGH_INTENDED;
+          [[fallthrough]];
         case ServerToClientPushState::kPushedMessageWithoutInitialMetadata:
         case ServerToClientPushState::kPushedServerInitialMetadata:
         case ServerToClientPushState::
@@ -1102,12 +1103,11 @@ CallState::PollWasCancelled() {
       << GRPC_DUMP_ARGS(this, server_trailing_metadata_state_);
   switch (server_trailing_metadata_state_) {
     case ServerTrailingMetadataState::kNotPushed:
-    case ServerTrailingMetadataState::kPushed:
-    case ServerTrailingMetadataState::kPushedCancel: {
       return server_trailing_metadata_waiter_.pending();
-    }
+    case ServerTrailingMetadataState::kPushed:
     case ServerTrailingMetadataState::kPulled:
       return false;
+    case ServerTrailingMetadataState::kPushedCancel:
     case ServerTrailingMetadataState::kPulledCancel:
       return true;
   }
@@ -1151,4 +1151,4 @@ CallState::PollServerTrailingMetadataWasPushed() {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_CALL_STATE_H
+#endif  // GRPC_SRC_CORE_CALL_CALL_STATE_H

data/src/core/{lib/surface → call}/client_call.cc

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "src/core/lib/surface/client_call.h"
+#include "src/core/call/client_call.h"
 
 #include <grpc/byte_buffer.h>
 #include <grpc/compression.h>
@@ -42,6 +42,7 @@
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
+#include "src/core/call/metadata.h"
 #include "src/core/lib/event_engine/event_engine_context.h"
 #include "src/core/lib/promise/all_ok.h"
 #include "src/core/lib/promise/status_flag.h"
@@ -49,7 +50,6 @@
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/surface/completion_queue.h"
-#include "src/core/lib/transport/metadata.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
 #include "src/core/util/bitset.h"
@@ -100,7 +100,7 @@ grpc_call_error ValidateClientBatch(const grpc_op* ops, size_t nops) {
 }  // namespace
 
 ClientCall::ClientCall(grpc_call*, uint32_t, grpc_completion_queue* cq,
-                       Slice path, absl::optional<Slice> authority,
+                       Slice path, std::optional<Slice> authority,
                        bool registered_method, Timestamp deadline,
                        grpc_compression_options compression_options,
                        RefCountedPtr<Arena> arena,
@@ -318,7 +318,7 @@ void ClientCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
           return Map(
               started_call_initiator_.PullServerInitialMetadata(),
               [this,
-               array](ValueOrFailure<absl::optional<ServerMetadataHandle>> md) {
+               array](ValueOrFailure<std::optional<ServerMetadataHandle>> md) {
                 ServerMetadataHandle metadata;
                 if (!md.ok() || !md->has_value()) {
                   is_trailers_only_ = true;
@@ -335,9 +335,16 @@ void ClientCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
               });
         };
       });
-  auto primary_ops = AllOk<StatusFlag>(
-      TrySeq(std::move(send_message), std::move(send_close_from_client)),
-      TrySeq(std::move(recv_initial_metadata), std::move(recv_message)));
+  // We capture 'this' in the op handlers, but the call may be destroyed before
+  // the party owned by CallInitiator/CallHandler is destroyed -- meaning that
+  // op callbacks may happen after call destruction if we don't hold a ref.
+  // We do that via an implicitly captured one in a Map() here so that we don't
+  // need a ref held per batch operation -- they have the same lifetime always.
+  auto primary_ops = Map(
+      AllOk<StatusFlag>(
+          TrySeq(std::move(send_message), std::move(send_close_from_client)),
+          TrySeq(std::move(recv_initial_metadata), std::move(recv_message))),
+      [self = WeakRef()](StatusFlag x) { return x; });
   Party::WakeupHold wakeup_hold;
   if (const grpc_op* op = op_index.op(GRPC_OP_SEND_INITIAL_METADATA)) {
     wakeup_hold = StartCall(*op);
@@ -397,12 +404,14 @@ void ClientCall::OnReceivedStatus(ServerMetadataHandle server_trailing_metadata,
   const auto status = server_trailing_metadata->get(GrpcStatusMetadata())
                           .value_or(GRPC_STATUS_UNKNOWN);
   *out_status = status;
-  Slice message_slice;
-  if (Slice* message =
-          server_trailing_metadata->get_pointer(GrpcMessageMetadata())) {
-    message_slice = message->Ref();
+  if (!IsErrorFlattenEnabled() || status != GRPC_STATUS_OK) {
+    Slice message_slice;
+    if (Slice* message =
+            server_trailing_metadata->get_pointer(GrpcMessageMetadata())) {
+      message_slice = message->Ref();
+    }
+    *out_status_details = message_slice.TakeCSlice();
   }
-  *out_status_details = message_slice.TakeCSlice();
   if (out_error_string != nullptr) {
     if (status != GRPC_STATUS_OK) {
       *out_error_string =
@@ -431,7 +440,7 @@ char* ClientCall::GetPeer() {
 
 grpc_call* MakeClientCall(grpc_call* parent_call, uint32_t propagation_mask,
                           grpc_completion_queue* cq, Slice path,
-                          absl::optional<Slice> authority,
+                          std::optional<Slice> authority,
                           bool registered_method, Timestamp deadline,
                           grpc_compression_options compression_options,
                           RefCountedPtr<Arena> arena,

data/src/core/{lib/surface → call}/client_call.h

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_SRC_CORE_LIB_SURFACE_CLIENT_CALL_H
-#define GRPC_SRC_CORE_LIB_SURFACE_CLIENT_CALL_H
+#ifndef GRPC_SRC_CORE_CALL_CLIENT_CALL_H
+#define GRPC_SRC_CORE_CALL_CLIENT_CALL_H
 
 #include <grpc/byte_buffer.h>
 #include <grpc/compression.h>
@@ -40,11 +40,11 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
+#include "src/core/call/metadata.h"
 #include "src/core/lib/promise/status_flag.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/call_utils.h"
-#include "src/core/lib/transport/metadata.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
@@ -59,7 +59,7 @@ class ClientCall final
  public:
   ClientCall(grpc_call* parent_call, uint32_t propagation_mask,
              grpc_completion_queue* cq, Slice path,
-             absl::optional<Slice> authority, bool registered_method,
+             std::optional<Slice> authority, bool registered_method,
              Timestamp deadline, grpc_compression_options compression_options,
              RefCountedPtr<Arena> arena,
              RefCountedPtr<UnstartedCallDestination> destination);
@@ -181,7 +181,7 @@ class ClientCall final
 
 grpc_call* MakeClientCall(grpc_call* parent_call, uint32_t propagation_mask,
                           grpc_completion_queue* cq, Slice path,
-                          absl::optional<Slice> authority,
+                          std::optional<Slice> authority,
                           bool registered_method, Timestamp deadline,
                           grpc_compression_options compression_options,
                           RefCountedPtr<Arena> arena,
@@ -189,4 +189,4 @@ grpc_call* MakeClientCall(grpc_call* parent_call, uint32_t propagation_mask,
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_SURFACE_CLIENT_CALL_H
+#endif  // GRPC_SRC_CORE_CALL_CLIENT_CALL_H

data/src/core/{lib/transport → call}/custom_metadata.h

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_SRC_CORE_LIB_TRANSPORT_CUSTOM_METADATA_H
-#define GRPC_SRC_CORE_LIB_TRANSPORT_CUSTOM_METADATA_H
+#ifndef GRPC_SRC_CORE_CALL_CUSTOM_METADATA_H
+#define GRPC_SRC_CORE_CALL_CUSTOM_METADATA_H
 
 // This file defines two macros: GRPC_CUSTOM_CLIENT_METADATA and
 // GRPC_CUSTOM_SERVER_METADATA.
@@ -27,4 +27,4 @@
 #define GRPC_CUSTOM_CLIENT_METADATA
 #define GRPC_CUSTOM_SERVER_METADATA
 
-#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_CUSTOM_METADATA_H
+#endif  // GRPC_SRC_CORE_CALL_CUSTOM_METADATA_H

data/src/core/{lib/transport → call}/interception_chain.cc

@@ -12,17 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "src/core/lib/transport/interception_chain.h"
+#include "src/core/call/interception_chain.h"
 
 #include <grpc/support/port_platform.h>
 
 #include <cstddef>
 
+#include "src/core/call/call_destination.h"
+#include "src/core/call/call_filters.h"
+#include "src/core/call/call_spine.h"
+#include "src/core/call/metadata.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/transport/call_destination.h"
-#include "src/core/lib/transport/call_filters.h"
-#include "src/core/lib/transport/call_spine.h"
-#include "src/core/lib/transport/metadata.h"
 #include "src/core/util/match.h"
 
 namespace grpc_core {