grpc 1.47.0-x86_64-linux → 1.49.0.pre1-x86_64-linux

data/src/core/ext/filters/client_channel/subchannel_pool_interface.cc

@@ -28,7 +28,6 @@
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/useful.h"
 
 // The subchannel pool to reuse subchannels.
 #define GRPC_ARG_SUBCHANNEL_POOL "grpc.internal.subchannel_pool"
@@ -40,39 +39,8 @@ namespace grpc_core {
 TraceFlag grpc_subchannel_pool_trace(false, "subchannel_pool");
 
 SubchannelKey::SubchannelKey(const grpc_resolved_address& address,
-                             const grpc_channel_args* args) {
-  Init(address, args, grpc_channel_args_normalize);
-}
-
-SubchannelKey::~SubchannelKey() {
-  grpc_channel_args_destroy(const_cast<grpc_channel_args*>(args_));
-}
-
-SubchannelKey::SubchannelKey(const SubchannelKey& other) {
-  Init(other.address_, other.args_, grpc_channel_args_copy);
-}
-
-SubchannelKey& SubchannelKey::operator=(const SubchannelKey& other) {
-  if (&other == this) {
-    return *this;
-  }
-  grpc_channel_args_destroy(const_cast<grpc_channel_args*>(args_));
-  Init(other.address_, other.args_, grpc_channel_args_copy);
-  return *this;
-}
-
-SubchannelKey::SubchannelKey(SubchannelKey&& other) noexcept {
-  address_ = other.address_;
-  args_ = other.args_;
-  other.args_ = nullptr;
-}
-
-SubchannelKey& SubchannelKey::operator=(SubchannelKey&& other) noexcept {
-  address_ = other.address_;
-  args_ = other.args_;
-  other.args_ = nullptr;
-  return *this;
-}
+                             const ChannelArgs& args)
+    : address_(address), args_(args) {}
 
 bool SubchannelKey::operator<(const SubchannelKey& other) const {
   if (address_.len < other.address_.len) return true;
@@ -80,14 +48,7 @@ bool SubchannelKey::operator<(const SubchannelKey& other) const {
   int r = memcmp(address_.addr, other.address_.addr, address_.len);
   if (r < 0) return true;
   if (r > 0) return false;
-  return grpc_channel_args_compare(args_, other.args_) < 0;
-}
-
-void SubchannelKey::Init(
-    const grpc_resolved_address& address, const grpc_channel_args* args,
-    grpc_channel_args* (*copy_channel_args)(const grpc_channel_args* args)) {
-  address_ = address;
-  args_ = copy_channel_args(args);
+  return args_ < other.args();
 }
 
 std::string SubchannelKey::ToString() const {
@@ -95,42 +56,11 @@ std::string SubchannelKey::ToString() const {
   return absl::StrCat(
       "{address=",
       addr_uri.ok() ? addr_uri.value() : addr_uri.status().ToString(),
-      ", args=", grpc_channel_args_string(args_), "}");
-}
-
-namespace {
-
-void* arg_copy(void* p) {
-  auto* subchannel_pool = static_cast<SubchannelPoolInterface*>(p);
-  subchannel_pool->Ref().release();
-  return p;
-}
-
-void arg_destroy(void* p) {
-  auto* subchannel_pool = static_cast<SubchannelPoolInterface*>(p);
-  subchannel_pool->Unref();
-}
-
-int arg_cmp(void* a, void* b) { return QsortCompare(a, b); }
-
-const grpc_arg_pointer_vtable subchannel_pool_arg_vtable = {
-    arg_copy, arg_destroy, arg_cmp};
-
-}  // namespace
-
-grpc_arg SubchannelPoolInterface::CreateChannelArg(
-    SubchannelPoolInterface* subchannel_pool) {
-  return grpc_channel_arg_pointer_create(
-      const_cast<char*>(GRPC_ARG_SUBCHANNEL_POOL), subchannel_pool,
-      &subchannel_pool_arg_vtable);
+      ", args=", args_.ToString(), "}");
 }
 
-SubchannelPoolInterface*
-SubchannelPoolInterface::GetSubchannelPoolFromChannelArgs(
-    const grpc_channel_args* args) {
-  const grpc_arg* arg = grpc_channel_args_find(args, GRPC_ARG_SUBCHANNEL_POOL);
-  if (arg == nullptr || arg->type != GRPC_ARG_POINTER) return nullptr;
-  return static_cast<SubchannelPoolInterface*>(arg->value.pointer.p);
+absl::string_view SubchannelPoolInterface::ChannelArgName() {
+  return GRPC_ARG_SUBCHANNEL_POOL;
 }
 
 }  // namespace grpc_core

data/src/core/ext/filters/client_channel/subchannel_pool_interface.h

@@ -23,9 +23,11 @@
 
 #include <string>
 
-#include <grpc/impl/codegen/grpc_types.h>
+#include "absl/strings/string_view.h"
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/resolved_address.h"
@@ -39,34 +41,24 @@ extern TraceFlag grpc_subchannel_pool_trace;
 // A key that can uniquely identify a subchannel.
 class SubchannelKey {
  public:
-  SubchannelKey(const grpc_resolved_address& address,
-                const grpc_channel_args* args);
-  ~SubchannelKey();
+  SubchannelKey(const grpc_resolved_address& address, const ChannelArgs& args);
 
-  // Copyable.
-  SubchannelKey(const SubchannelKey& other);
-  SubchannelKey& operator=(const SubchannelKey& other);
-  // Movable
-  SubchannelKey(SubchannelKey&&) noexcept;
-  SubchannelKey& operator=(SubchannelKey&&) noexcept;
+  SubchannelKey(const SubchannelKey& other) = default;
+  SubchannelKey& operator=(const SubchannelKey& other) = default;
+  SubchannelKey(SubchannelKey&& other) noexcept = default;
+  SubchannelKey& operator=(SubchannelKey&& other) noexcept = default;
 
   bool operator<(const SubchannelKey& other) const;
 
   const grpc_resolved_address& address() const { return address_; }
-  const grpc_channel_args* args() const { return args_; }
+  const ChannelArgs& args() const { return args_; }
 
   // Human-readable string suitable for logging.
   std::string ToString() const;
 
  private:
-  // Initializes the subchannel key with the given \a args and the function to
-  // copy channel args.
-  void Init(
-      const grpc_resolved_address& address, const grpc_channel_args* args,
-      grpc_channel_args* (*copy_channel_args)(const grpc_channel_args* args));
-
   grpc_resolved_address address_;
-  const grpc_channel_args* args_;
+  ChannelArgs args_;
 };
 
 // Interface for subchannel pool.
@@ -81,6 +73,12 @@ class SubchannelPoolInterface : public RefCounted<SubchannelPoolInterface> {
                        : nullptr) {}
   ~SubchannelPoolInterface() override {}
 
+  static absl::string_view ChannelArgName();
+  static int ChannelArgsCompare(const SubchannelPoolInterface* a,
+                                const SubchannelPoolInterface* b) {
+    return QsortCompare(a, b);
+  }
+
   // Registers a subchannel against a key. Returns the subchannel registered
   // with \a key, which may be different from \a constructed because we reuse
   // (instead of update) any existing subchannel already registered with \a key.
@@ -95,13 +93,6 @@ class SubchannelPoolInterface : public RefCounted<SubchannelPoolInterface> {
   // if no such channel exists. Thread-safe.
   virtual RefCountedPtr<Subchannel> FindSubchannel(
       const SubchannelKey& key) = 0;
-
-  // Creates a channel arg from \a subchannel pool.
-  static grpc_arg CreateChannelArg(SubchannelPoolInterface* subchannel_pool);
-
-  // Gets the subchannel pool from the channel args.
-  static SubchannelPoolInterface* GetSubchannelPoolFromChannelArgs(
-      const grpc_channel_args* args);
 };
 
 }  // namespace grpc_core

data/src/core/ext/filters/client_channel/subchannel_stream_client.cc

@@ -20,25 +20,20 @@
 
 #include <inttypes.h>
 #include <stdio.h>
-#include <string.h>
 
-#include <cstdint>
 #include <string>
 #include <utility>
 
-#include <grpc/slice_buffer.h>
 #include <grpc/status.h>
-#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/time_precise.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
-#include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/transport/error_utils.h"
 
 #define SUBCHANNEL_STREAM_INITIAL_CONNECT_BACKOFF_SECONDS 1
@@ -61,7 +56,8 @@ SubchannelStreamClient::SubchannelStreamClient(
       interested_parties_(interested_parties),
       tracer_(tracer),
       call_allocator_(
-          ResourceQuotaFromChannelArgs(connected_subchannel_->args())
+          connected_subchannel_->args()
+              .GetObject<ResourceQuota>()
               ->memory_quota()
               ->CreateMemoryAllocator(
                   (tracer != nullptr) ? tracer : "SubchannelStreamClient")),
@@ -151,7 +147,7 @@ void SubchannelStreamClient::OnRetryTimer(void* arg, grpc_error_handle error) {
   {
     MutexLock lock(&self->mu_);
     self->retry_timer_callback_pending_ = false;
-    if (self->event_handler_ != nullptr && error == GRPC_ERROR_NONE &&
+    if (self->event_handler_ != nullptr && GRPC_ERROR_IS_NONE(error) &&
         self->call_state_ == nullptr) {
       if (GPR_UNLIKELY(self->tracer_ != nullptr)) {
         gpr_log(GPR_INFO,
@@ -223,7 +219,7 @@ void SubchannelStreamClient::CallState::StartCallLocked() {
                     this, grpc_schedule_on_exec_ctx);
   call_->SetAfterCallStackDestroy(&after_call_stack_destruction_);
   // Check if creation failed.
-  if (error != GRPC_ERROR_NONE ||
+  if (!GRPC_ERROR_IS_NONE(error) ||
       subchannel_stream_client_->event_handler_ == nullptr) {
     gpr_log(GPR_ERROR,
             "SubchannelStreamClient %p CallState %p: error creating "
@@ -245,21 +241,15 @@ void SubchannelStreamClient::CallState::StartCallLocked() {
   send_initial_metadata_.Set(
       HttpPathMetadata(),
       subchannel_stream_client_->event_handler_->GetPathLocked());
-  GPR_ASSERT(error == GRPC_ERROR_NONE);
+  GPR_ASSERT(GRPC_ERROR_IS_NONE(error));
   payload_.send_initial_metadata.send_initial_metadata =
       &send_initial_metadata_;
-  payload_.send_initial_metadata.send_initial_metadata_flags = 0;
   payload_.send_initial_metadata.peer_string = nullptr;
   batch_.send_initial_metadata = true;
   // Add send_message op.
-  grpc_slice request_slice =
-      subchannel_stream_client_->event_handler_->EncodeSendMessageLocked();
-  grpc_slice_buffer slice_buffer;
-  grpc_slice_buffer_init(&slice_buffer);
-  grpc_slice_buffer_add(&slice_buffer, request_slice);
-  send_message_.emplace(&slice_buffer, 0);
-  grpc_slice_buffer_destroy_internal(&slice_buffer);
-  payload_.send_message.send_message.reset(&*send_message_);
+  send_message_.Append(Slice(
+      subchannel_stream_client_->event_handler_->EncodeSendMessageLocked()));
+  payload_.send_message.send_message = &send_message_;
   batch_.send_message = true;
   // Add send_trailing_metadata op.
   payload_.send_trailing_metadata.send_trailing_metadata =
@@ -268,7 +258,6 @@ void SubchannelStreamClient::CallState::StartCallLocked() {
   // Add recv_initial_metadata op.
   payload_.recv_initial_metadata.recv_initial_metadata =
       &recv_initial_metadata_;
-  payload_.recv_initial_metadata.recv_flags = nullptr;
   payload_.recv_initial_metadata.trailing_metadata_available = nullptr;
   payload_.recv_initial_metadata.peer_string = nullptr;
   // recv_initial_metadata_ready callback takes ref, handled manually.
@@ -374,42 +363,18 @@ void SubchannelStreamClient::CallState::RecvInitialMetadataReady(
   self->call_->Unref(DEBUG_LOCATION, "recv_initial_metadata_ready");
 }
 
-void SubchannelStreamClient::CallState::DoneReadingRecvMessage(
-    grpc_error_handle error) {
-  recv_message_.reset();
-  if (error != GRPC_ERROR_NONE) {
-    GRPC_ERROR_UNREF(error);
-    Cancel();
-    grpc_slice_buffer_destroy_internal(&recv_message_buffer_);
+void SubchannelStreamClient::CallState::RecvMessageReady() {
+  if (!recv_message_.has_value()) {
     call_->Unref(DEBUG_LOCATION, "recv_message_ready");
     return;
   }
-  // Concatenate the slices to form a single string.
-  std::unique_ptr<uint8_t> recv_message_deleter;
-  uint8_t* recv_message;
-  if (recv_message_buffer_.count == 1) {
-    recv_message = GRPC_SLICE_START_PTR(recv_message_buffer_.slices[0]);
-  } else {
-    recv_message =
-        static_cast<uint8_t*>(gpr_malloc(recv_message_buffer_.length));
-    recv_message_deleter.reset(recv_message);
-    size_t offset = 0;
-    for (size_t i = 0; i < recv_message_buffer_.count; ++i) {
-      memcpy(recv_message + offset,
-             GRPC_SLICE_START_PTR(recv_message_buffer_.slices[i]),
-             GRPC_SLICE_LENGTH(recv_message_buffer_.slices[i]));
-      offset += GRPC_SLICE_LENGTH(recv_message_buffer_.slices[i]);
-    }
-  }
   // Report payload.
   {
     MutexLock lock(&subchannel_stream_client_->mu_);
     if (subchannel_stream_client_->event_handler_ != nullptr) {
-      absl::string_view serialized_message(
-          reinterpret_cast<char*>(recv_message), recv_message_buffer_.length);
       absl::Status status =
           subchannel_stream_client_->event_handler_->RecvMessageReadyLocked(
-              subchannel_stream_client_.get(), serialized_message);
+              subchannel_stream_client_.get(), recv_message_->JoinIntoString());
       if (!status.ok()) {
         if (GPR_UNLIKELY(subchannel_stream_client_->tracer_ != nullptr)) {
           gpr_log(GPR_INFO,
@@ -424,7 +389,7 @@ void SubchannelStreamClient::CallState::DoneReadingRecvMessage(
     }
   }
   seen_response_.store(true, std::memory_order_release);
-  grpc_slice_buffer_destroy_internal(&recv_message_buffer_);
+  recv_message_.reset();
   // Start another recv_message batch.
   // This re-uses the ref we're holding.
   // Note: Can't just reuse batch_ here, since we don't know that all
@@ -438,62 +403,11 @@ void SubchannelStreamClient::CallState::DoneReadingRecvMessage(
   StartBatch(&recv_message_batch_);
 }
 
-grpc_error_handle
-SubchannelStreamClient::CallState::PullSliceFromRecvMessage() {
-  grpc_slice slice;
-  grpc_error_handle error = recv_message_->Pull(&slice);
-  if (error == GRPC_ERROR_NONE) {
-    grpc_slice_buffer_add(&recv_message_buffer_, slice);
-  }
-  return error;
-}
-
-void SubchannelStreamClient::CallState::ContinueReadingRecvMessage() {
-  while (recv_message_->Next(SIZE_MAX, &recv_message_ready_)) {
-    grpc_error_handle error = PullSliceFromRecvMessage();
-    if (error != GRPC_ERROR_NONE) {
-      DoneReadingRecvMessage(error);
-      return;
-    }
-    if (recv_message_buffer_.length == recv_message_->length()) {
-      DoneReadingRecvMessage(GRPC_ERROR_NONE);
-      break;
-    }
-  }
-}
-
-void SubchannelStreamClient::CallState::OnByteStreamNext(
-    void* arg, grpc_error_handle error) {
-  auto* self = static_cast<SubchannelStreamClient::CallState*>(arg);
-  if (error != GRPC_ERROR_NONE) {
-    self->DoneReadingRecvMessage(GRPC_ERROR_REF(error));
-    return;
-  }
-  error = self->PullSliceFromRecvMessage();
-  if (error != GRPC_ERROR_NONE) {
-    self->DoneReadingRecvMessage(error);
-    return;
-  }
-  if (self->recv_message_buffer_.length == self->recv_message_->length()) {
-    self->DoneReadingRecvMessage(GRPC_ERROR_NONE);
-  } else {
-    self->ContinueReadingRecvMessage();
-  }
-}
-
 void SubchannelStreamClient::CallState::RecvMessageReady(
     void* arg, grpc_error_handle /*error*/) {
   auto* self = static_cast<SubchannelStreamClient::CallState*>(arg);
   GRPC_CALL_COMBINER_STOP(&self->call_combiner_, "recv_message_ready");
-  if (self->recv_message_ == nullptr) {
-    self->call_->Unref(DEBUG_LOCATION, "recv_message_ready");
-    return;
-  }
-  grpc_slice_buffer_init(&self->recv_message_buffer_);
-  GRPC_CLOSURE_INIT(&self->recv_message_ready_, OnByteStreamNext, self,
-                    grpc_schedule_on_exec_ctx);
-  self->ContinueReadingRecvMessage();
-  // Ref will continue to be held until we finish draining the byte stream.
+  self->RecvMessageReady();
 }
 
 void SubchannelStreamClient::CallState::RecvTrailingMetadataReady(
@@ -505,7 +419,7 @@ void SubchannelStreamClient::CallState::RecvTrailingMetadataReady(
   grpc_status_code status =
       self->recv_trailing_metadata_.get(GrpcStatusMetadata())
           .value_or(GRPC_STATUS_UNKNOWN);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_error_get_status(error, Timestamp::InfFuture(), &status,
                           nullptr /* slice */, nullptr /* http_error */,
                           nullptr /* error_string */);

data/src/core/ext/filters/client_channel/subchannel_stream_client.h

@@ -46,7 +46,7 @@
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/slice/slice.h"
-#include "src/core/lib/transport/byte_stream.h"
+#include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 
@@ -132,6 +132,8 @@ class SubchannelStreamClient
     void CallEndedLocked(bool retry)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&subchannel_stream_client_->mu_);
 
+    void RecvMessageReady();
+
     static void OnComplete(void* arg, grpc_error_handle error);
     static void RecvInitialMetadataReady(void* arg, grpc_error_handle error);
     static void RecvMessageReady(void* arg, grpc_error_handle error);
@@ -139,11 +141,6 @@ class SubchannelStreamClient
     static void StartCancel(void* arg, grpc_error_handle error);
     static void OnCancelComplete(void* arg, grpc_error_handle error);
 
-    static void OnByteStreamNext(void* arg, grpc_error_handle error);
-    void ContinueReadingRecvMessage();
-    grpc_error_handle PullSliceFromRecvMessage();
-    void DoneReadingRecvMessage(grpc_error_handle error);
-
     static void AfterCallStackDestruction(void* arg, grpc_error_handle error);
 
     RefCountedPtr<SubchannelStreamClient> subchannel_stream_client_;
@@ -169,7 +166,7 @@ class SubchannelStreamClient
     grpc_metadata_batch send_initial_metadata_;
 
     // send_message
-    absl::optional<SliceBufferByteStream> send_message_;
+    SliceBuffer send_message_;
 
     // send_trailing_metadata
     grpc_metadata_batch send_trailing_metadata_;
@@ -179,9 +176,8 @@ class SubchannelStreamClient
     grpc_closure recv_initial_metadata_ready_;
 
     // recv_message
-    OrphanablePtr<ByteStream> recv_message_;
+    absl::optional<SliceBuffer> recv_message_;
     grpc_closure recv_message_ready_;
-    grpc_slice_buffer recv_message_buffer_;
     std::atomic<bool> seen_response_{false};
 
     // True if the cancel_stream batch has been started.

data/src/core/ext/filters/deadline/deadline_filter.cc

@@ -18,19 +18,25 @@
 
 #include "src/core/ext/filters/deadline/deadline_filter.h"
 
-#include <stdbool.h>
-#include <string.h>
+#include <new>
 
-#include <grpc/support/alloc.h>
+#include "absl/status/status.h"
+#include "absl/types/optional.h"
+
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/status.h>
 #include <grpc/support/log.h>
-#include <grpc/support/sync.h>
-#include <grpc/support/time.h>
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/surface/channel_init.h"
+#include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/transport/metadata_batch.h"
 
 namespace grpc_core {
 
@@ -369,10 +375,10 @@ const grpc_channel_filter grpc_server_deadline_filter = {
     "deadline",
 };
 
-bool grpc_deadline_checking_enabled(const grpc_channel_args* channel_args) {
-  return grpc_channel_arg_get_bool(
-      grpc_channel_args_find(channel_args, GRPC_ARG_ENABLE_DEADLINE_CHECKS),
-      !grpc_channel_args_want_minimal_stack(channel_args));
+bool grpc_deadline_checking_enabled(
+    const grpc_core::ChannelArgs& channel_args) {
+  return channel_args.GetBool(GRPC_ARG_ENABLE_DEADLINE_CHECKS)
+      .value_or(!channel_args.WantMinimalStack());
 }
 
 namespace grpc_core {
@@ -383,8 +389,7 @@ void RegisterDeadlineFilter(CoreConfiguration::Builder* builder) {
         type, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
         [filter](ChannelStackBuilder* builder) {
           auto args = builder->channel_args();
-          if (args.GetBool(GRPC_ARG_ENABLE_DEADLINE_CHECKS)
-                  .value_or(!args.WantMinimalStack())) {
+          if (grpc_deadline_checking_enabled(args)) {
             builder->PrependFilter(filter);
           }
           return true;

data/src/core/ext/filters/deadline/deadline_filter.h

@@ -19,8 +19,14 @@
 
 #include <grpc/support/port_platform.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"
-#include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/call_combiner.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/resource_quota/arena.h"
+#include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 class TimerState;
@@ -76,7 +82,7 @@ void grpc_deadline_state_client_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* op);
 
 // Should deadline checking be performed (according to channel args)
-bool grpc_deadline_checking_enabled(const grpc_channel_args* args);
+bool grpc_deadline_checking_enabled(const grpc_core::ChannelArgs& args);
 
 // Deadline filters for direct client channels and server channels.
 // Note: Deadlines for non-direct client channels are handled by the

data/src/core/ext/filters/fault_injection/fault_injection_filter.cc

@@ -18,21 +18,38 @@
 
 #include "src/core/ext/filters/fault_injection/fault_injection_filter.h"
 
+#include <stdint.h>
+#include <stdlib.h>
+
+#include <algorithm>
 #include <atomic>
+#include <functional>
+#include <string>
+#include <utility>
 
+#include "absl/status/status.h"
 #include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "absl/utility/utility.h"
 
 #include <grpc/status.h>
-#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/filters/fault_injection/service_config_parser.h"
 #include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/context.h"
 #include "src/core/lib/channel/status_util.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/sleep.h"
 #include "src/core/lib/promise/try_seq.h"
 #include "src/core/lib/service_config/service_config_call_data.h"
-#include "src/core/lib/transport/status_conversion.h"
+#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
@@ -113,7 +130,7 @@ class FaultInjectionFilter::InjectionDecision {
 };
 
 absl::StatusOr<FaultInjectionFilter> FaultInjectionFilter::Create(
-    ChannelArgs, ChannelFilter::Args filter_args) {
+    const ChannelArgs&, ChannelFilter::Args filter_args) {
   return FaultInjectionFilter(filter_args);
 }
 

data/src/core/ext/filters/fault_injection/fault_injection_filter.h

@@ -19,9 +19,14 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/fault_injection/service_config_parser.h"
-#include "src/core/lib/channel/channel_stack.h"
+#include <stddef.h>
+
+#include "absl/status/statusor.h"
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/promise_based_filter.h"
+#include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/transport/transport.h"
 
 // Channel arg key for enabling parsing fault injection via method config.
@@ -39,7 +44,7 @@ class FaultInjectionFilter : public ChannelFilter {
   static const grpc_channel_filter kFilter;
 
   static absl::StatusOr<FaultInjectionFilter> Create(
-      ChannelArgs args, ChannelFilter::Args filter_args);
+      const ChannelArgs& args, ChannelFilter::Args filter_args);
 
   // Construct a promise for one call.
   ArenaPromise<ServerMetadataHandle> MakeCallPromise(
@@ -53,7 +58,7 @@ class FaultInjectionFilter : public ChannelFilter {
       const ClientMetadataHandle& initial_metadata);
 
   // The relative index of instances of the same filter.
-  int index_;
+  size_t index_;
   const size_t service_config_parser_index_;
 };