grpc 1.44.0.pre2 → 1.45.0

data/src/core/ext/filters/client_idle/client_idle_filter.cc

@@ -25,8 +25,14 @@
 #include "src/core/ext/filters/client_idle/idle_filter_state.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
+#include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/gprpp/capture.h"
 #include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/promise/exec_ctx_wakeup_scheduler.h"
+#include "src/core/lib/promise/loop.h"
+#include "src/core/lib/promise/sleep.h"
+#include "src/core/lib/promise/try_seq.h"
 #include "src/core/lib/transport/http2_errors.h"
 
 // TODO(juanlishen): The idle filter is disabled in client channel by default
@@ -48,217 +54,148 @@ TraceFlag grpc_trace_client_idle_filter(false, "client_idle_filter");
 
 namespace {
 
-grpc_millis GetClientIdleTimeout(const grpc_channel_args* args) {
-  return std::max(
+Duration GetClientIdleTimeout(const grpc_channel_args* args) {
+  auto millis = std::max(
       grpc_channel_arg_get_integer(
           grpc_channel_args_find(args, GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS),
           {DEFAULT_IDLE_TIMEOUT_MS, 0, INT_MAX}),
       MIN_IDLE_TIMEOUT_MS);
+  if (millis == INT_MAX) return Duration::Infinity();
+  return Duration::Milliseconds(millis);
 }
 
-class ChannelData {
+class ClientIdleFilter : public ChannelFilter {
  public:
-  static grpc_error_handle Init(grpc_channel_element* elem,
-                                grpc_channel_element_args* args);
-  static void Destroy(grpc_channel_element* elem);
+  static absl::StatusOr<ClientIdleFilter> Create(
+      const grpc_channel_args* args, ChannelFilter::Args filter_args);
+  ~ClientIdleFilter() override = default;
 
-  static void StartTransportOp(grpc_channel_element* elem,
-                               grpc_transport_op* op);
+  ClientIdleFilter(const ClientIdleFilter&) = delete;
+  ClientIdleFilter& operator=(const ClientIdleFilter&) = delete;
+  ClientIdleFilter(ClientIdleFilter&&) = default;
+  ClientIdleFilter& operator=(ClientIdleFilter&&) = default;
 
-  void IncreaseCallCount();
+  // Construct a promise for one call.
+  ArenaPromise<TrailingMetadata> MakeCallPromise(
+      ClientInitialMetadata initial_metadata,
+      NextPromiseFactory next_promise_factory) override;
 
-  void DecreaseCallCount();
+  bool StartTransportOp(grpc_transport_op* op) override;
 
  private:
-  ChannelData(grpc_channel_element* elem, grpc_channel_element_args* args,
-              grpc_error_handle* error);
-  ~ChannelData() = default;
-
-  static void IdleTimerCallback(void* arg, grpc_error_handle error);
-  static void IdleTransportOpCompleteCallback(void* arg,
-                                              grpc_error_handle error);
+  ClientIdleFilter(grpc_channel_stack* channel_stack,
+                   Duration client_idle_timeout)
+      : channel_stack_(channel_stack),
+        client_idle_timeout_(client_idle_timeout) {}
 
   void StartIdleTimer();
 
-  void EnterIdle();
+  void IncreaseCallCount();
+  void DecreaseCallCount();
+
+  struct CallCountDecreaser {
+    void operator()(ClientIdleFilter* filter) const {
+      filter->DecreaseCallCount();
+    }
+  };
 
-  grpc_channel_element* elem_;
   // The channel stack to which we take refs for pending callbacks.
   grpc_channel_stack* channel_stack_;
-  // Timeout after the last RPC finishes on the client channel at which the
-  // channel goes back into IDLE state.
-  const grpc_millis client_idle_timeout_;
-
-  // Member data used to track the state of channel.
-  IdleFilterState idle_filter_state_{false};
+  Duration client_idle_timeout_;
+  std::shared_ptr<IdleFilterState> idle_filter_state_{
+      std::make_shared<IdleFilterState>(false)};
 
-  // Idle timer and its callback closure.
-  grpc_timer idle_timer_;
-  grpc_closure idle_timer_callback_;
-
-  // The transport op telling the client channel to enter IDLE.
-  grpc_transport_op idle_transport_op_;
-  grpc_closure idle_transport_op_complete_callback_;
+  ActivityPtr activity_;
 };
 
-grpc_error_handle ChannelData::Init(grpc_channel_element* elem,
-                                    grpc_channel_element_args* args) {
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  new (elem->channel_data) ChannelData(elem, args, &error);
-  return error;
+absl::StatusOr<ClientIdleFilter> ClientIdleFilter::Create(
+    const grpc_channel_args* args, ChannelFilter::Args filter_args) {
+  ClientIdleFilter filter(filter_args.channel_stack(),
+                          GetClientIdleTimeout(args));
+  return absl::StatusOr<ClientIdleFilter>(std::move(filter));
 }
 
-void ChannelData::Destroy(grpc_channel_element* elem) {
-  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
-  chand->~ChannelData();
+// Construct a promise for one call.
+ArenaPromise<TrailingMetadata> ClientIdleFilter::MakeCallPromise(
+    ClientInitialMetadata initial_metadata,
+    NextPromiseFactory next_promise_factory) {
+  using Decrementer = std::unique_ptr<ClientIdleFilter, CallCountDecreaser>;
+  IncreaseCallCount();
+  return ArenaPromise<TrailingMetadata>(Capture(
+      [](Decrementer*, ArenaPromise<TrailingMetadata>* next)
+          -> Poll<TrailingMetadata> { return (*next)(); },
+      Decrementer(this), next_promise_factory(std::move(initial_metadata))));
 }
 
-void ChannelData::StartTransportOp(grpc_channel_element* elem,
-                                   grpc_transport_op* op) {
-  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
+bool ClientIdleFilter::StartTransportOp(grpc_transport_op* op) {
   // Catch the disconnect_with_error transport op.
   if (op->disconnect_with_error != GRPC_ERROR_NONE) {
     // IncreaseCallCount() introduces a phony call and prevent the timer from
     // being reset by other threads.
-    chand->IncreaseCallCount();
-    // If the timer has been set, cancel the timer.
-    // No synchronization issues here. grpc_timer_cancel() is valid as long as
-    // the timer has been init()ed before.
-    grpc_timer_cancel(&chand->idle_timer_);
+    IncreaseCallCount();
+    activity_.reset();
   }
   // Pass the op to the next filter.
-  grpc_channel_next_op(elem, op);
+  return false;
 }
 
-void ChannelData::IncreaseCallCount() {
-  idle_filter_state_.IncreaseCallCount();
+void ClientIdleFilter::IncreaseCallCount() {
+  idle_filter_state_->IncreaseCallCount();
 }
 
-void ChannelData::DecreaseCallCount() {
-  if (idle_filter_state_.DecreaseCallCount()) {
+void ClientIdleFilter::DecreaseCallCount() {
+  if (idle_filter_state_->DecreaseCallCount()) {
     // If there are no more calls in progress, start the idle timer.
     StartIdleTimer();
   }
 }
 
-ChannelData::ChannelData(grpc_channel_element* elem,
-                         grpc_channel_element_args* args,
-                         grpc_error_handle* /*error*/)
-    : elem_(elem),
-      channel_stack_(args->channel_stack),
-      client_idle_timeout_(GetClientIdleTimeout(args->channel_args)) {
-  // If the idle filter is explicitly disabled in channel args, this ctor should
-  // not get called.
-  GPR_ASSERT(client_idle_timeout_ != GRPC_MILLIS_INF_FUTURE);
-  GRPC_IDLE_FILTER_LOG("created with max_leisure_time = %" PRId64 " ms",
-                       client_idle_timeout_);
-  // Initialize the idle timer without setting it.
-  grpc_timer_init_unset(&idle_timer_);
-  // Initialize the idle timer callback closure.
-  GRPC_CLOSURE_INIT(&idle_timer_callback_, IdleTimerCallback, this,
-                    grpc_schedule_on_exec_ctx);
-  // Initialize the idle transport op complete callback.
-  GRPC_CLOSURE_INIT(&idle_transport_op_complete_callback_,
-                    IdleTransportOpCompleteCallback, this,
-                    grpc_schedule_on_exec_ctx);
-}
-
-void ChannelData::IdleTimerCallback(void* arg, grpc_error_handle error) {
-  GRPC_IDLE_FILTER_LOG("timer alarms");
-  ChannelData* chand = static_cast<ChannelData*>(arg);
-  if (error != GRPC_ERROR_NONE) {
-    GRPC_IDLE_FILTER_LOG("timer canceled");
-    GRPC_CHANNEL_STACK_UNREF(chand->channel_stack_, "max idle timer callback");
-    return;
-  }
-  if (chand->idle_filter_state_.CheckTimer()) {
-    chand->StartIdleTimer();
-  } else {
-    chand->EnterIdle();
-  }
-  GRPC_IDLE_FILTER_LOG("timer finishes");
-  GRPC_CHANNEL_STACK_UNREF(chand->channel_stack_, "max idle timer callback");
-}
-
-void ChannelData::IdleTransportOpCompleteCallback(void* arg,
-                                                  grpc_error_handle /*error*/) {
-  ChannelData* chand = static_cast<ChannelData*>(arg);
-  GRPC_CHANNEL_STACK_UNREF(chand->channel_stack_, "idle transport op");
-}
-
-void ChannelData::StartIdleTimer() {
+void ClientIdleFilter::StartIdleTimer() {
   GRPC_IDLE_FILTER_LOG("timer has started");
+  auto idle_filter_state = idle_filter_state_;
   // Hold a ref to the channel stack for the timer callback.
-  GRPC_CHANNEL_STACK_REF(channel_stack_, "max idle timer callback");
-  grpc_timer_init(&idle_timer_, ExecCtx::Get()->Now() + client_idle_timeout_,
-                  &idle_timer_callback_);
-}
-
-void ChannelData::EnterIdle() {
-  GRPC_IDLE_FILTER_LOG("the channel will enter IDLE");
-  // Hold a ref to the channel stack for the transport op.
-  GRPC_CHANNEL_STACK_REF(channel_stack_, "idle transport op");
-  // Initialize the transport op.
-  idle_transport_op_ = {};
-  idle_transport_op_.disconnect_with_error = grpc_error_set_int(
-      GRPC_ERROR_CREATE_FROM_STATIC_STRING("enter idle"),
-      GRPC_ERROR_INT_CHANNEL_CONNECTIVITY_STATE, GRPC_CHANNEL_IDLE);
-  idle_transport_op_.on_consumed = &idle_transport_op_complete_callback_;
-  // Pass the transport op down to the channel stack.
-  grpc_channel_next_op(elem_, &idle_transport_op_);
-}
-
-class CallData {
- public:
-  static grpc_error_handle Init(grpc_call_element* elem,
-                                const grpc_call_element_args* args);
-  static void Destroy(grpc_call_element* elem,
-                      const grpc_call_final_info* final_info,
-                      grpc_closure* then_schedule_closure);
-};
-
-grpc_error_handle CallData::Init(grpc_call_element* elem,
-                                 const grpc_call_element_args* /*args*/) {
-  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
-  chand->IncreaseCallCount();
-  return GRPC_ERROR_NONE;
-}
-
-void CallData::Destroy(grpc_call_element* elem,
-                       const grpc_call_final_info* /*final_info*/,
-                       grpc_closure* /*ignored*/) {
-  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
-  chand->DecreaseCallCount();
+  auto channel_stack = channel_stack_->Ref();
+  auto timeout = client_idle_timeout_;
+  auto promise = Loop([timeout, idle_filter_state]() {
+    return TrySeq(Sleep(ExecCtx::Get()->Now() + timeout),
+                  [idle_filter_state]() -> Poll<LoopCtl<absl::Status>> {
+                    if (idle_filter_state->CheckTimer()) {
+                      return Continue{};
+                    } else {
+                      return absl::OkStatus();
+                    }
+                  });
+  });
+  activity_ = MakeActivity(
+      std::move(promise), ExecCtxWakeupScheduler{},
+      [channel_stack](absl::Status status) {
+        if (!status.ok()) return;
+        auto* op = grpc_make_transport_op(nullptr);
+        op->disconnect_with_error = grpc_error_set_int(
+            GRPC_ERROR_CREATE_FROM_STATIC_STRING("enter idle"),
+            GRPC_ERROR_INT_CHANNEL_CONNECTIVITY_STATE, GRPC_CHANNEL_IDLE);
+        // Pass the transport op down to the channel stack.
+        auto* elem = grpc_channel_stack_element(channel_stack.get(), 0);
+        elem->filter->start_transport_op(elem, op);
+      });
 }
 
-const grpc_channel_filter grpc_client_idle_filter = {
-    grpc_call_next_op,
-    ChannelData::StartTransportOp,
-    sizeof(CallData),
-    CallData::Init,
-    grpc_call_stack_ignore_set_pollset_or_pollset_set,
-    CallData::Destroy,
-    sizeof(ChannelData),
-    ChannelData::Init,
-    ChannelData::Destroy,
-    grpc_channel_next_get_info,
-    "client_idle"};
+const grpc_channel_filter grpc_client_idle_filter =
+    MakePromiseBasedFilter<ClientIdleFilter, FilterEndpoint::kClient>(
+        "client_idle");
 
 }  // namespace
 
 void RegisterClientIdleFilter(CoreConfiguration::Builder* builder) {
   builder->channel_init()->RegisterStage(
       GRPC_CLIENT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      [](grpc_channel_stack_builder* builder) {
-        const grpc_channel_args* channel_args =
-            grpc_channel_stack_builder_get_channel_arguments(builder);
+      [](ChannelStackBuilder* builder) {
+        const grpc_channel_args* channel_args = builder->channel_args();
         if (!grpc_channel_args_want_minimal_stack(channel_args) &&
-            GetClientIdleTimeout(channel_args) != INT_MAX) {
-          return grpc_channel_stack_builder_prepend_filter(
-              builder, &grpc_client_idle_filter, nullptr, nullptr);
-        } else {
-          return true;
+            GetClientIdleTimeout(channel_args) != Duration::Infinity()) {
+          builder->PrependFilter(&grpc_client_idle_filter, nullptr);
         }
+        return true;
       });
 }
 }  // namespace grpc_core

data/src/core/ext/filters/client_idle/idle_filter_state.h

@@ -29,8 +29,8 @@ class IdleFilterState {
   explicit IdleFilterState(bool start_timer);
   ~IdleFilterState() = default;
 
-  IdleFilterState(const IdleFilterState&);
-  IdleFilterState& operator=(const IdleFilterState&);
+  IdleFilterState(const IdleFilterState&) = delete;
+  IdleFilterState& operator=(const IdleFilterState&) = delete;
 
   // Increment the number of calls in progress.
   void IncreaseCallCount();

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

@@ -38,7 +38,7 @@ namespace grpc_core {
 // Allocated on the call arena.
 class TimerState {
  public:
-  TimerState(grpc_call_element* elem, grpc_millis deadline) : elem_(elem) {
+  TimerState(grpc_call_element* elem, Timestamp deadline) : elem_(elem) {
     grpc_deadline_state* deadline_state =
         static_cast<grpc_deadline_state*>(elem_->call_data);
     GRPC_CALL_STACK_REF(deadline_state->call_stack, "DeadlineTimerState");
@@ -113,8 +113,8 @@ class TimerState {
 // This is called via the call combiner, so access to deadline_state is
 // synchronized.
 static void start_timer_if_needed(grpc_call_element* elem,
-                                  grpc_millis deadline) {
-  if (deadline == GRPC_MILLIS_INF_FUTURE) return;
+                                  grpc_core::Timestamp deadline) {
+  if (deadline == grpc_core::Timestamp::InfFuture()) return;
   grpc_deadline_state* deadline_state =
       static_cast<grpc_deadline_state*>(elem->call_data);
   GPR_ASSERT(deadline_state->timer_state == nullptr);
@@ -157,13 +157,14 @@ static void inject_recv_trailing_metadata_ready(
 // Callback and associated state for starting the timer after call stack
 // initialization has been completed.
 struct start_timer_after_init_state {
-  start_timer_after_init_state(grpc_call_element* elem, grpc_millis deadline)
+  start_timer_after_init_state(grpc_call_element* elem,
+                               grpc_core::Timestamp deadline)
       : elem(elem), deadline(deadline) {}
   ~start_timer_after_init_state() { start_timer_if_needed(elem, deadline); }
 
   bool in_call_combiner = false;
   grpc_call_element* elem;
-  grpc_millis deadline;
+  grpc_core::Timestamp deadline;
   grpc_closure closure;
 };
 static void start_timer_after_init(void* arg, grpc_error_handle error) {
@@ -187,13 +188,13 @@ static void start_timer_after_init(void* arg, grpc_error_handle error) {
 
 grpc_deadline_state::grpc_deadline_state(grpc_call_element* elem,
                                          const grpc_call_element_args& args,
-                                         grpc_millis deadline)
+                                         grpc_core::Timestamp deadline)
     : call_stack(args.call_stack),
       call_combiner(args.call_combiner),
       arena(args.arena) {
   // Deadline will always be infinite on servers, so the timer will only be
   // set on clients with a finite deadline.
-  if (deadline != GRPC_MILLIS_INF_FUTURE) {
+  if (deadline != grpc_core::Timestamp::InfFuture()) {
     // When the deadline passes, we indicate the failure by sending down
     // an op with cancel_error set.  However, we can't send down any ops
     // until after the call stack is fully initialized.  If we start the
@@ -212,7 +213,7 @@ grpc_deadline_state::grpc_deadline_state(grpc_call_element* elem,
 grpc_deadline_state::~grpc_deadline_state() { cancel_timer_if_needed(this); }
 
 void grpc_deadline_state_reset(grpc_call_element* elem,
-                               grpc_millis new_deadline) {
+                               grpc_core::Timestamp new_deadline) {
   grpc_deadline_state* deadline_state =
       static_cast<grpc_deadline_state*>(elem->call_data);
   cancel_timer_if_needed(deadline_state);
@@ -295,7 +296,7 @@ static void recv_initial_metadata_ready(void* arg, grpc_error_handle error) {
   server_call_data* calld = static_cast<server_call_data*>(elem->call_data);
   start_timer_if_needed(
       elem, calld->recv_initial_metadata->get(grpc_core::GrpcTimeoutMetadata())
-                .value_or(GRPC_MILLIS_INF_FUTURE));
+                .value_or(grpc_core::Timestamp::InfFuture()));
   // Invoke the next callback.
   grpc_core::Closure::Run(DEBUG_LOCATION,
                           calld->next_recv_initial_metadata_ready,
@@ -338,6 +339,7 @@ static void deadline_server_start_transport_stream_op_batch(
 
 const grpc_channel_filter grpc_client_deadline_filter = {
     deadline_client_start_transport_stream_op_batch,
+    nullptr,
     grpc_channel_next_op,
     sizeof(base_call_data),
     deadline_init_call_elem,
@@ -352,6 +354,7 @@ const grpc_channel_filter grpc_client_deadline_filter = {
 
 const grpc_channel_filter grpc_server_deadline_filter = {
     deadline_server_start_transport_stream_op_batch,
+    nullptr,
     grpc_channel_next_op,
     sizeof(server_call_data),
     deadline_init_call_elem,
@@ -376,11 +379,9 @@ void RegisterDeadlineFilter(CoreConfiguration::Builder* builder) {
                                    const grpc_channel_filter* filter) {
     builder->channel_init()->RegisterStage(
         type, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-        [filter](grpc_channel_stack_builder* builder) {
-          if (grpc_deadline_checking_enabled(
-                  grpc_channel_stack_builder_get_channel_arguments(builder))) {
-            return grpc_channel_stack_builder_prepend_filter(builder, filter,
-                                                             nullptr, nullptr);
+        [filter](ChannelStackBuilder* builder) {
+          if (grpc_deadline_checking_enabled(builder->channel_args())) {
+            builder->PrependFilter(filter, nullptr);
           }
           return true;
         });

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

@@ -30,7 +30,8 @@ class TimerState;
 // Must be the first field in the filter's call_data.
 struct grpc_deadline_state {
   grpc_deadline_state(grpc_call_element* elem,
-                      const grpc_call_element_args& args, grpc_millis deadline);
+                      const grpc_call_element_args& args,
+                      grpc_core::Timestamp deadline);
   ~grpc_deadline_state();
 
   // We take a reference to the call stack for the timer callback.
@@ -61,7 +62,7 @@ struct grpc_deadline_state {
 //
 // Note: Must be called while holding the call combiner.
 void grpc_deadline_state_reset(grpc_call_element* elem,
-                               grpc_millis new_deadline);
+                               grpc_core::Timestamp new_deadline);
 
 // To be called from the client-side filter's start_transport_stream_op_batch()
 // method.  Ensures that the deadline timer is cancelled when the call

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

@@ -69,6 +69,9 @@ class ChannelData {
   static void Destroy(grpc_channel_element* elem);
 
   int index() const { return index_; }
+  size_t service_config_parser_index() const {
+    return service_config_parser_index_;
+  }
 
  private:
   ChannelData(grpc_channel_element* elem, grpc_channel_element_args* args);
@@ -76,6 +79,7 @@ class ChannelData {
 
   // The relative index of instances of the same filter.
   int index_;
+  const size_t service_config_parser_index_;
 };
 
 class CallData {
@@ -170,8 +174,10 @@ void ChannelData::Destroy(grpc_channel_element* elem) {
 
 ChannelData::ChannelData(grpc_channel_element* elem,
                          grpc_channel_element_args* args)
-    : index_(grpc_channel_stack_filter_instance_number(args->channel_stack,
-                                                       elem)) {}
+    : index_(
+          grpc_channel_stack_filter_instance_number(args->channel_stack, elem)),
+      service_config_parser_index_(
+          FaultInjectionServiceConfigParser::ParserIndex()) {}
 
 // CallData::ResumeBatchCanceller
 
@@ -294,7 +300,7 @@ CallData::CallData(grpc_call_element* elem, const grpc_call_element_args* args)
       args->context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value);
   auto* method_params = static_cast<FaultInjectionMethodParsedConfig*>(
       service_config_call_data->GetMethodParsedConfig(
-          FaultInjectionServiceConfigParser::ParserIndex()));
+          chand->service_config_parser_index()));
   if (method_params != nullptr) {
     fi_policy_ = method_params->fault_injection_policy(chand->index());
   }
@@ -351,12 +357,13 @@ void CallData::DecideWhetherToInjectFaults(
       }
     }
     if (!fi_policy_->delay_header.empty() &&
-        (copied_policy == nullptr || copied_policy->delay == 0)) {
+        (copied_policy == nullptr ||
+         copied_policy->delay == Duration::Zero())) {
       auto value =
           initial_metadata->GetStringValue(fi_policy_->delay_header, &buffer);
       if (value.has_value()) {
         maybe_copy_policy_func();
-        copied_policy->delay = static_cast<grpc_millis>(
+        copied_policy->delay = Duration::Milliseconds(
             std::max(AsInt<int64_t>(*value).value_or(0), int64_t(0)));
       }
     }
@@ -373,7 +380,7 @@ void CallData::DecideWhetherToInjectFaults(
     if (copied_policy != nullptr) fi_policy_ = copied_policy;
   }
   // Roll the dice
-  delay_request_ = fi_policy_->delay != 0 &&
+  delay_request_ = fi_policy_->delay != Duration::Zero() &&
                    UnderFraction(fi_policy_->delay_percentage_numerator,
                                  fi_policy_->delay_percentage_denominator);
   abort_request_ = fi_policy_->abort_code != GRPC_STATUS_OK &&
@@ -417,7 +424,7 @@ void CallData::DelayBatch(grpc_call_element* elem,
   MutexLock lock(&delay_mu_);
   delayed_batch_ = batch;
   resume_batch_canceller_ = new ResumeBatchCanceller(elem);
-  grpc_millis resume_time = ExecCtx::Get()->Now() + fi_policy_->delay;
+  Timestamp resume_time = ExecCtx::Get()->Now() + fi_policy_->delay;
   GRPC_CLOSURE_INIT(&batch->handler_private.closure, ResumeBatch, elem,
                     grpc_schedule_on_exec_ctx);
   grpc_timer_init(&delay_timer_, resume_time, &batch->handler_private.closure);
@@ -471,6 +478,7 @@ void CallData::HijackedRecvTrailingMetadataReady(void* arg,
 
 extern const grpc_channel_filter FaultInjectionFilterVtable = {
     CallData::StartTransportStreamOpBatch,
+    nullptr,
     grpc_channel_next_op,
     sizeof(CallData),
     CallData::Init,
@@ -483,10 +491,8 @@ extern const grpc_channel_filter FaultInjectionFilterVtable = {
     "fault_injection_filter",
 };
 
-void FaultInjectionFilterInit(void) {
-  FaultInjectionServiceConfigParser::Register();
+void FaultInjectionFilterRegister(CoreConfiguration::Builder* builder) {
+  FaultInjectionServiceConfigParser::Register(builder);
 }
 
-void FaultInjectionFilterShutdown(void) {}
-
 }  // namespace grpc_core

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

@@ -33,8 +33,6 @@ namespace grpc_core {
 
 namespace {
 
-size_t g_fault_injection_parser_index;
-
 std::vector<FaultInjectionMethodParsedConfig::FaultInjectionPolicy>
 ParseFaultInjectionPolicy(const Json::Array& policies_json_array,
                           std::vector<grpc_error_handle>* error_list) {
@@ -167,13 +165,15 @@ FaultInjectionServiceConfigParser::ParsePerMethodParams(
       std::move(fault_injection_policies));
 }
 
-void FaultInjectionServiceConfigParser::Register() {
-  g_fault_injection_parser_index = ServiceConfigParser::RegisterParser(
+void FaultInjectionServiceConfigParser::Register(
+    CoreConfiguration::Builder* builder) {
+  builder->service_config_parser()->RegisterParser(
       absl::make_unique<FaultInjectionServiceConfigParser>());
 }
 
 size_t FaultInjectionServiceConfigParser::ParserIndex() {
-  return g_fault_injection_parser_index;
+  return CoreConfiguration::Get().service_config_parser().GetParserIndex(
+      parser_name());
 }
 
 }  // namespace grpc_core

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

@@ -21,6 +21,7 @@
 
 #include <vector>
 
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/service_config/service_config_parser.h"
 
@@ -37,7 +38,7 @@ class FaultInjectionMethodParsedConfig
     uint32_t abort_percentage_numerator = 0;
     uint32_t abort_percentage_denominator = 100;
 
-    grpc_millis delay = 0;
+    Duration delay;
     std::string delay_header;
     std::string delay_percentage_header;
     uint32_t delay_percentage_numerator = 0;
@@ -68,8 +69,10 @@ class FaultInjectionMethodParsedConfig
   std::vector<FaultInjectionPolicy> fault_injection_policies_;
 };
 
-class FaultInjectionServiceConfigParser : public ServiceConfigParser::Parser {
+class FaultInjectionServiceConfigParser final
+    : public ServiceConfigParser::Parser {
  public:
+  absl::string_view name() const override { return parser_name(); }
   // Parses the per-method service config for fault injection filter.
   std::unique_ptr<ServiceConfigParser::ParsedConfig> ParsePerMethodParams(
       const grpc_channel_args* args, const Json& json,
@@ -77,7 +80,10 @@ class FaultInjectionServiceConfigParser : public ServiceConfigParser::Parser {
   // Returns the parser index for FaultInjectionServiceConfigParser.
   static size_t ParserIndex();
   // Registers FaultInjectionServiceConfigParser to ServiceConfigParser.
-  static void Register();
+  static void Register(CoreConfiguration::Builder* builder);
+
+ private:
+  static absl::string_view parser_name() { return "fault_injection"; }
 };
 
 }  // namespace grpc_core

data/src/core/ext/filters/http/client/http_client_filter.cc

@@ -32,6 +32,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/profiling/timers.h"
@@ -489,12 +490,14 @@ static grpc_error_handle http_client_init_channel_elem(
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   new (chand) channel_data();
   GPR_ASSERT(!args->is_last);
-  GPR_ASSERT(args->optional_transport != nullptr);
+  auto* transport = grpc_channel_args_find_pointer<grpc_transport>(
+      args->channel_args, GRPC_ARG_TRANSPORT);
+  GPR_ASSERT(transport != nullptr);
   chand->static_scheme = scheme_from_args(args->channel_args);
   chand->max_payload_size_for_get =
       max_payload_size_from_args(args->channel_args);
-  chand->user_agent = grpc_core::Slice(user_agent_from_args(
-      args->channel_args, args->optional_transport->vtable->name));
+  chand->user_agent = grpc_core::Slice(
+      user_agent_from_args(args->channel_args, transport->vtable->name));
   return GRPC_ERROR_NONE;
 }
 
@@ -505,6 +508,7 @@ static void http_client_destroy_channel_elem(grpc_channel_element* elem) {
 
 const grpc_channel_filter grpc_http_client_filter = {
     http_client_start_transport_stream_op_batch,
+    nullptr,
     grpc_channel_next_op,
     sizeof(call_data),
     http_client_init_call_elem,