grpc 1.54.2 → 1.61.0

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

@@ -24,11 +24,9 @@
 #include <functional>
 #include <map>
 #include <memory>
-#include <string>
 
 #include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
-#include "absl/types/optional.h"
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/connectivity_state.h>
@@ -56,6 +54,7 @@
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/iomgr/resolved_address.h"
+#include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/connectivity_state.h"
@@ -86,6 +85,8 @@ class ConnectedSubchannel : public RefCounted<ConnectedSubchannel> {
 
   size_t GetInitialCallSizeEstimate() const;
 
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(CallArgs call_args);
+
  private:
   grpc_channel_stack* channel_stack_;
   ChannelArgs args_;
@@ -121,9 +122,9 @@ class SubchannelCall {
   void SetAfterCallStackDestroy(grpc_closure* closure);
 
   // Interface of RefCounted<>.
-  RefCountedPtr<SubchannelCall> Ref() GRPC_MUST_USE_RESULT;
-  RefCountedPtr<SubchannelCall> Ref(const DebugLocation& location,
-                                    const char* reason) GRPC_MUST_USE_RESULT;
+  GRPC_MUST_USE_RESULT RefCountedPtr<SubchannelCall> Ref();
+  GRPC_MUST_USE_RESULT RefCountedPtr<SubchannelCall> Ref(
+      const DebugLocation& location, const char* reason);
   // When refcount drops to 0, destroys itself and the associated call stack,
   // but does NOT free the memory because it's in the call arena.
   void Unref();
@@ -175,8 +176,14 @@ class Subchannel : public DualRefCounted<Subchannel> {
     // Invoked whenever the subchannel's connectivity state changes.
     // There will be only one invocation of this method on a given watcher
     // instance at any given time.
-    virtual void OnConnectivityStateChange(grpc_connectivity_state state,
-                                           const absl::Status& status) = 0;
+    // A ref to the watcher is passed in here so that the implementation
+    // can unref it in the appropriate synchronization context (e.g.,
+    // inside a WorkSerializer).
+    // TODO(roth): Figure out a cleaner way to guarantee that the ref is
+    // released in the right context.
+    virtual void OnConnectivityStateChange(
+        RefCountedPtr<ConnectivityStateWatcherInterface> self,
+        grpc_connectivity_state state, const absl::Status& status) = 0;
 
     virtual grpc_pollset_set* interested_parties() = 0;
   };
@@ -214,6 +221,8 @@ class Subchannel : public DualRefCounted<Subchannel> {
 
   channelz::SubchannelNode* channelz_node();
 
+  const grpc_resolved_address& address() const { return key_.address(); }
+
   // Starts watching the subchannel's connectivity state.
   // The first callback to the watcher will be delivered ~immediately.
   // Subsequent callbacks will be delivered as the subchannel's state
@@ -221,15 +230,13 @@ class Subchannel : public DualRefCounted<Subchannel> {
   // The watcher will be destroyed either when the subchannel is
   // destroyed or when CancelConnectivityStateWatch() is called.
   void WatchConnectivityState(
-      const absl::optional<std::string>& health_check_service_name,
       RefCountedPtr<ConnectivityStateWatcherInterface> watcher)
       ABSL_LOCKS_EXCLUDED(mu_);
 
   // Cancels a connectivity state watch.
   // If the watcher has already been destroyed, this is a no-op.
-  void CancelConnectivityStateWatch(
-      const absl::optional<std::string>& health_check_service_name,
-      ConnectivityStateWatcherInterface* watcher) ABSL_LOCKS_EXCLUDED(mu_);
+  void CancelConnectivityStateWatch(ConnectivityStateWatcherInterface* watcher)
+      ABSL_LOCKS_EXCLUDED(mu_);
 
   RefCountedPtr<ConnectedSubchannel> connected_subchannel()
       ABSL_LOCKS_EXCLUDED(mu_) {
@@ -265,6 +272,10 @@ class Subchannel : public DualRefCounted<Subchannel> {
   void RemoveDataProducer(DataProducerInterface* data_producer)
       ABSL_LOCKS_EXCLUDED(mu_);
 
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine() {
+    return event_engine_;
+  }
+
  private:
   // A linked list of ConnectivityStateWatcherInterfaces that are monitoring
   // the subchannel's state.
@@ -296,40 +307,6 @@ class Subchannel : public DualRefCounted<Subchannel> {
         watchers_;
   };
 
-  // A map that tracks ConnectivityStateWatcherInterfaces using a particular
-  // health check service name.
-  //
-  // There is one entry in the map for each health check service name.
-  // Entries exist only as long as there are watchers using the
-  // corresponding service name.
-  //
-  // A health check client is maintained only while the subchannel is in
-  // state READY.
-  class HealthWatcherMap {
-   public:
-    void AddWatcherLocked(
-        WeakRefCountedPtr<Subchannel> subchannel,
-        const std::string& health_check_service_name,
-        RefCountedPtr<ConnectivityStateWatcherInterface> watcher);
-    void RemoveWatcherLocked(const std::string& health_check_service_name,
-                             ConnectivityStateWatcherInterface* watcher);
-
-    // Notifies the watcher when the subchannel's state changes.
-    void NotifyLocked(grpc_connectivity_state state, const absl::Status& status)
-        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&Subchannel::mu_);
-
-    grpc_connectivity_state CheckConnectivityStateLocked(
-        Subchannel* subchannel, const std::string& health_check_service_name)
-        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&Subchannel::mu_);
-
-    void ShutdownLocked();
-
-   private:
-    class HealthWatcher;
-
-    std::map<std::string, OrphanablePtr<HealthWatcher>> map_;
-  };
-
   class ConnectedSubchannelStateWatcher;
 
   // Sets the subchannel's connectivity state to \a state.
@@ -382,10 +359,8 @@ class Subchannel : public DualRefCounted<Subchannel> {
   // - TRANSIENT_FAILURE: connection attempt failed, retry timer pending
   grpc_connectivity_state state_ ABSL_GUARDED_BY(mu_) = GRPC_CHANNEL_IDLE;
   absl::Status status_ ABSL_GUARDED_BY(mu_);
-  // The list of watchers without a health check service name.
+  // The list of connectivity state watchers.
   ConnectivityStateWatcherList watcher_list_ ABSL_GUARDED_BY(mu_);
-  // The map of watchers with health check service names.
-  HealthWatcherMap health_watcher_map_ ABSL_GUARDED_BY(mu_);
   // Used for sending connectivity state notifications.
   WorkSerializer work_serializer_;
 

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

@@ -20,6 +20,7 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/filters/client_channel/subchannel.h"
+#include "src/core/lib/gprpp/unique_type_name.h"
 #include "src/core/lib/load_balancing/subchannel_interface.h"
 
 namespace grpc_core {
@@ -29,6 +30,8 @@ namespace grpc_core {
 class InternalSubchannelDataWatcherInterface
     : public SubchannelInterface::DataWatcherInterface {
  public:
+  virtual UniqueTypeName type() const = 0;
+
   // Tells the watcher which subchannel to register itself with.
   virtual void SetSubchannel(Subchannel* subchannel) = 0;
 };

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

@@ -21,7 +21,6 @@
 #include <inttypes.h>
 #include <stdio.h>
 
-#include <string>
 #include <utility>
 
 #include <grpc/status.h>

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

@@ -26,12 +26,10 @@
 #include "absl/status/status.h"
 #include "absl/types/optional.h"
 
-#include <grpc/grpc.h>
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/status.h>
 #include <grpc/support/log.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/debug_location.h"
 #include "src/core/lib/gprpp/status_helper.h"
@@ -41,7 +39,6 @@
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/surface/call.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"
 
@@ -346,6 +343,7 @@ const grpc_channel_filter grpc_client_deadline_filter = {
        grpc_core::NextPromiseFactory next_promise_factory) {
       return next_promise_factory(std::move(call_args));
     },
+    /* init_call: */ nullptr,
     grpc_channel_next_op,
     sizeof(grpc_deadline_state),
     deadline_init_call_elem,
@@ -371,6 +369,17 @@ const grpc_channel_filter grpc_server_deadline_filter = {
       }
       return next_promise_factory(std::move(call_args));
     },
+    [](grpc_channel_element*, grpc_core::CallSpineInterface* spine) {
+      spine->client_initial_metadata().receiver.InterceptAndMap(
+          [](grpc_core::ClientMetadataHandle md) {
+            auto deadline = md->get(grpc_core::GrpcTimeoutMetadata());
+            if (deadline.has_value()) {
+              grpc_core::GetContext<grpc_core::CallContext>()->UpdateDeadline(
+                  *deadline);
+            }
+            return md;
+          });
+    },
     grpc_channel_next_op,
     sizeof(server_call_data),
     deadline_init_call_elem,
@@ -384,27 +393,15 @@ const grpc_channel_filter grpc_server_deadline_filter = {
     "deadline",
 };
 
-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 {
 void RegisterDeadlineFilter(CoreConfiguration::Builder* builder) {
-  auto register_filter = [builder](grpc_channel_stack_type type,
-                                   const grpc_channel_filter* filter) {
-    builder->channel_init()->RegisterStage(
-        type, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-        [filter](ChannelStackBuilder* builder) {
-          auto args = builder->channel_args();
-          if (grpc_deadline_checking_enabled(args)) {
-            builder->PrependFilter(filter);
-          }
-          return true;
-        });
-  };
-  register_filter(GRPC_CLIENT_DIRECT_CHANNEL, &grpc_client_deadline_filter);
-  register_filter(GRPC_SERVER_CHANNEL, &grpc_server_deadline_filter);
+  builder->channel_init()
+      ->RegisterFilter(GRPC_CLIENT_DIRECT_CHANNEL, &grpc_client_deadline_filter)
+      .ExcludeFromMinimalStack()
+      .IfChannelArg(GRPC_ARG_ENABLE_DEADLINE_CHECKS, true);
+  builder->channel_init()
+      ->RegisterFilter(GRPC_SERVER_CHANNEL, &grpc_server_deadline_filter)
+      .ExcludeFromMinimalStack()
+      .IfChannelArg(GRPC_ARG_ENABLE_DEADLINE_CHECKS, true);
 }
 }  // namespace grpc_core

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

@@ -19,7 +19,6 @@
 
 #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/gprpp/time.h"
@@ -77,9 +76,6 @@ void grpc_deadline_state_reset(grpc_deadline_state* deadline_state,
 void grpc_deadline_state_client_start_transport_stream_op_batch(
     grpc_deadline_state* deadline_state, grpc_transport_stream_op_batch* op);
 
-// Should deadline checking be performed (according to channel 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
 // client_channel filter.

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

@@ -27,6 +27,7 @@
 #include <type_traits>
 #include <utility>
 
+#include "absl/meta/type_traits.h"
 #include "absl/status/status.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
@@ -53,6 +54,11 @@
 namespace grpc_core {
 
 TraceFlag grpc_fault_injection_filter_trace(false, "fault_injection_filter");
+const NoInterceptor FaultInjectionFilter::Call::OnServerInitialMetadata;
+const NoInterceptor FaultInjectionFilter::Call::OnServerTrailingMetadata;
+const NoInterceptor FaultInjectionFilter::Call::OnClientToServerMessage;
+const NoInterceptor FaultInjectionFilter::Call::OnServerToClientMessage;
+const NoInterceptor FaultInjectionFilter::Call::OnFinalize;
 
 namespace {
 
@@ -143,23 +149,22 @@ FaultInjectionFilter::FaultInjectionFilter(ChannelFilter::Args filter_args)
       mu_(new Mutex) {}
 
 // Construct a promise for one call.
-ArenaPromise<ServerMetadataHandle> FaultInjectionFilter::MakeCallPromise(
-    CallArgs call_args, NextPromiseFactory next_promise_factory) {
-  auto decision = MakeInjectionDecision(call_args.client_initial_metadata);
+ArenaPromise<absl::Status> FaultInjectionFilter::Call::OnClientInitialMetadata(
+    ClientMetadata& md, FaultInjectionFilter* filter) {
+  auto decision = filter->MakeInjectionDecision(md);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_fault_injection_filter_trace)) {
     gpr_log(GPR_INFO, "chand=%p: Fault injection triggered %s", this,
             decision.ToString().c_str());
   }
   auto delay = decision.DelayUntil();
-  return TrySeq(
-      Sleep(delay),
-      [decision = std::move(decision)]() { return decision.MaybeAbort(); },
-      next_promise_factory(std::move(call_args)));
+  return TrySeq(Sleep(delay), [decision = std::move(decision)]() {
+    return decision.MaybeAbort();
+  });
 }
 
 FaultInjectionFilter::InjectionDecision
 FaultInjectionFilter::MakeInjectionDecision(
-    const ClientMetadataHandle& initial_metadata) {
+    const ClientMetadata& initial_metadata) {
   // Fetch the fault injection policy from the service config, based on the
   // relative index for which policy should this CallData use.
   auto* service_config_call_data = static_cast<ServiceConfigCallData*>(
@@ -187,15 +192,15 @@ FaultInjectionFilter::MakeInjectionDecision(
       !fi_policy->delay_percentage_header.empty()) {
     std::string buffer;
     if (!fi_policy->abort_code_header.empty() && abort_code == GRPC_STATUS_OK) {
-      auto value = initial_metadata->GetStringValue(
-          fi_policy->abort_code_header, &buffer);
+      auto value = initial_metadata.GetStringValue(fi_policy->abort_code_header,
+                                                   &buffer);
       if (value.has_value()) {
         grpc_status_code_from_int(
             AsInt<int>(*value).value_or(GRPC_STATUS_UNKNOWN), &abort_code);
       }
     }
     if (!fi_policy->abort_percentage_header.empty()) {
-      auto value = initial_metadata->GetStringValue(
+      auto value = initial_metadata.GetStringValue(
           fi_policy->abort_percentage_header, &buffer);
       if (value.has_value()) {
         abort_percentage_numerator = std::min(
@@ -204,14 +209,14 @@ FaultInjectionFilter::MakeInjectionDecision(
     }
     if (!fi_policy->delay_header.empty() && delay == Duration::Zero()) {
       auto value =
-          initial_metadata->GetStringValue(fi_policy->delay_header, &buffer);
+          initial_metadata.GetStringValue(fi_policy->delay_header, &buffer);
       if (value.has_value()) {
         delay = Duration::Milliseconds(
             std::max(AsInt<int64_t>(*value).value_or(0), int64_t{0}));
       }
     }
     if (!fi_policy->delay_percentage_header.empty()) {
-      auto value = initial_metadata->GetStringValue(
+      auto value = initial_metadata.GetStringValue(
           fi_policy->delay_percentage_header, &buffer);
       if (value.has_value()) {
         delay_percentage_numerator = std::min(

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

@@ -40,7 +40,8 @@ namespace grpc_core {
 // of the ordinary channel stack. The fault injection filter fetches fault
 // injection policy from the method config of service config returned by the
 // resolver, and enforces the fault injection policy.
-class FaultInjectionFilter : public ChannelFilter {
+class FaultInjectionFilter
+    : public ImplementChannelFilter<FaultInjectionFilter> {
  public:
   static const grpc_channel_filter kFilter;
 
@@ -48,15 +49,23 @@ class FaultInjectionFilter : public ChannelFilter {
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 
   // Construct a promise for one call.
-  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
-      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+  class Call {
+   public:
+    ArenaPromise<absl::Status> OnClientInitialMetadata(
+        ClientMetadata& md, FaultInjectionFilter* filter);
+    static const NoInterceptor OnServerInitialMetadata;
+    static const NoInterceptor OnServerTrailingMetadata;
+    static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnServerToClientMessage;
+    static const NoInterceptor OnFinalize;
+  };
 
  private:
   explicit FaultInjectionFilter(ChannelFilter::Args filter_args);
 
   class InjectionDecision;
   InjectionDecision MakeInjectionDecision(
-      const ClientMetadataHandle& initial_metadata);
+      const ClientMetadata& initial_metadata);
 
   // The relative index of instances of the same filter.
   size_t index_;

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

@@ -58,7 +58,7 @@ void FaultInjectionMethodParsedConfig::FaultInjectionPolicy::JsonPostLoad(
     const Json& json, const JsonArgs& args, ValidationErrors* errors) {
   // Parse abort_code.
   auto abort_code_string = LoadJsonObjectField<std::string>(
-      json.object_value(), args, "abortCode", errors, /*required=*/false);
+      json.object(), args, "abortCode", errors, /*required=*/false);
   if (abort_code_string.has_value() &&
       !grpc_status_code_from_string(abort_code_string->c_str(), &abort_code)) {
     ValidationErrors::ScopedField field(errors, ".abortCode");

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

@@ -21,7 +21,6 @@
 
 #include <algorithm>
 #include <functional>
-#include <initializer_list>
 #include <memory>
 #include <string>
 #include <utility>
@@ -35,6 +34,7 @@
 #include "absl/types/optional.h"
 
 #include <grpc/grpc.h>
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/status.h>
 
 #include "src/core/lib/channel/channel_args.h"
@@ -43,16 +43,18 @@
 #include "src/core/lib/promise/latch.h"
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/pipe.h"
-#include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/race.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/percent_encoding.h"
 #include "src/core/lib/transport/status_conversion.h"
-#include "src/core/lib/transport/transport_fwd.h"
-#include "src/core/lib/transport/transport_impl.h"
+#include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 
+const NoInterceptor HttpClientFilter::Call::OnServerToClientMessage;
+const NoInterceptor HttpClientFilter::Call::OnClientToServerMessage;
+const NoInterceptor HttpClientFilter::Call::OnFinalize;
+
 const grpc_channel_filter HttpClientFilter::kFilter =
     MakePromiseBasedFilter<HttpClientFilter, FilterEndpoint::kClient,
                            kFilterExaminesServerInitialMetadata>("http-client");
@@ -91,7 +93,8 @@ HttpSchemeMetadata::ValueType SchemeFromArgs(const ChannelArgs& args) {
   return scheme;
 }
 
-Slice UserAgentFromArgs(const ChannelArgs& args, const char* transport_name) {
+Slice UserAgentFromArgs(const ChannelArgs& args,
+                        absl::string_view transport_name) {
   std::vector<std::string> fields;
   auto add = [&fields](absl::string_view x) {
     if (!x.empty()) fields.push_back(std::string(x));
@@ -106,40 +109,27 @@ Slice UserAgentFromArgs(const ChannelArgs& args, const char* transport_name) {
 }
 }  // namespace
 
-ArenaPromise<ServerMetadataHandle> HttpClientFilter::MakeCallPromise(
-    CallArgs call_args, NextPromiseFactory next_promise_factory) {
-  auto& md = call_args.client_initial_metadata;
-  if (test_only_use_put_requests_) {
-    md->Set(HttpMethodMetadata(), HttpMethodMetadata::kPut);
+void HttpClientFilter::Call::OnClientInitialMetadata(ClientMetadata& md,
+                                                     HttpClientFilter* filter) {
+  if (filter->test_only_use_put_requests_) {
+    md.Set(HttpMethodMetadata(), HttpMethodMetadata::kPut);
   } else {
-    md->Set(HttpMethodMetadata(), HttpMethodMetadata::kPost);
+    md.Set(HttpMethodMetadata(), HttpMethodMetadata::kPost);
   }
-  md->Set(HttpSchemeMetadata(), scheme_);
-  md->Set(TeMetadata(), TeMetadata::kTrailers);
-  md->Set(ContentTypeMetadata(), ContentTypeMetadata::kApplicationGrpc);
-  md->Set(UserAgentMetadata(), user_agent_.Ref());
-
-  auto* initial_metadata_err =
-      GetContext<Arena>()->New<Latch<ServerMetadataHandle>>();
-
-  call_args.server_initial_metadata->InterceptAndMap(
-      [initial_metadata_err](
-          ServerMetadataHandle md) -> absl::optional<ServerMetadataHandle> {
-        auto r = CheckServerMetadata(md.get());
-        if (!r.ok()) {
-          initial_metadata_err->Set(ServerMetadataFromStatus(r));
-          return absl::nullopt;
-        }
-        return std::move(md);
-      });
-
-  return Race(initial_metadata_err->Wait(),
-              Map(next_promise_factory(std::move(call_args)),
-                  [](ServerMetadataHandle md) -> ServerMetadataHandle {
-                    auto r = CheckServerMetadata(md.get());
-                    if (!r.ok()) return ServerMetadataFromStatus(r);
-                    return md;
-                  }));
+  md.Set(HttpSchemeMetadata(), filter->scheme_);
+  md.Set(TeMetadata(), TeMetadata::kTrailers);
+  md.Set(ContentTypeMetadata(), ContentTypeMetadata::kApplicationGrpc);
+  md.Set(UserAgentMetadata(), filter->user_agent_.Ref());
+}
+
+absl::Status HttpClientFilter::Call::OnServerInitialMetadata(
+    ServerMetadata& md) {
+  return CheckServerMetadata(&md);
+}
+
+absl::Status HttpClientFilter::Call::OnServerTrailingMetadata(
+    ServerMetadata& md) {
+  return CheckServerMetadata(&md);
 }
 
 HttpClientFilter::HttpClientFilter(HttpSchemeMetadata::ValueType scheme,
@@ -151,12 +141,13 @@ HttpClientFilter::HttpClientFilter(HttpSchemeMetadata::ValueType scheme,
 
 absl::StatusOr<HttpClientFilter> HttpClientFilter::Create(
     const ChannelArgs& args, ChannelFilter::Args) {
-  auto* transport = args.GetObject<grpc_transport>();
+  auto* transport = args.GetObject<Transport>();
   if (transport == nullptr) {
     return absl::InvalidArgumentError("HttpClientFilter needs a transport");
   }
   return HttpClientFilter(
-      SchemeFromArgs(args), UserAgentFromArgs(args, transport->vtable->name),
+      SchemeFromArgs(args),
+      UserAgentFromArgs(args, transport->GetTransportName()),
       args.GetInt(GRPC_ARG_TEST_ONLY_USE_PUT_REQUESTS).value_or(false));
 }
 

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

@@ -25,23 +25,28 @@
 #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/slice/slice.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 
-class HttpClientFilter : public ChannelFilter {
+class HttpClientFilter : public ImplementChannelFilter<HttpClientFilter> {
  public:
   static const grpc_channel_filter kFilter;
 
   static absl::StatusOr<HttpClientFilter> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 
-  // Construct a promise for one call.
-  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
-      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+  class Call {
+   public:
+    void OnClientInitialMetadata(ClientMetadata& md, HttpClientFilter* filter);
+    absl::Status OnServerInitialMetadata(ServerMetadata& md);
+    absl::Status OnServerTrailingMetadata(ServerMetadata& md);
+    static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnServerToClientMessage;
+    static const NoInterceptor OnFinalize;
+  };
 
  private:
   HttpClientFilter(HttpSchemeMetadata::ValueType scheme, Slice user_agent,

data/src/core/ext/filters/http/client_authority_filter.cc

@@ -20,8 +20,6 @@
 
 #include "src/core/ext/filters/http/client_authority_filter.h"
 
-#include <limits.h>
-
 #include <functional>
 #include <memory>
 
@@ -29,16 +27,22 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-#include <grpc/grpc.h>
+#include <grpc/impl/channel_arg_names.h>
 
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/security/transport/auth_filters.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/metadata_batch.h"
 
 namespace grpc_core {
 
+const NoInterceptor ClientAuthorityFilter::Call::OnServerInitialMetadata;
+const NoInterceptor ClientAuthorityFilter::Call::OnServerTrailingMetadata;
+const NoInterceptor ClientAuthorityFilter::Call::OnClientToServerMessage;
+const NoInterceptor ClientAuthorityFilter::Call::OnServerToClientMessage;
+const NoInterceptor ClientAuthorityFilter::Call::OnFinalize;
+
 absl::StatusOr<ClientAuthorityFilter> ClientAuthorityFilter::Create(
     const ChannelArgs& args, ChannelFilter::Args) {
   absl::optional<absl::string_view> default_authority =
@@ -51,17 +55,12 @@ absl::StatusOr<ClientAuthorityFilter> ClientAuthorityFilter::Create(
   return ClientAuthorityFilter(Slice::FromCopiedString(*default_authority));
 }
 
-ArenaPromise<ServerMetadataHandle> ClientAuthorityFilter::MakeCallPromise(
-    CallArgs call_args, NextPromiseFactory next_promise_factory) {
+void ClientAuthorityFilter::Call::OnClientInitialMetadata(
+    ClientMetadata& md, ClientAuthorityFilter* filter) {
   // If no authority is set, set the default authority.
-  if (call_args.client_initial_metadata->get_pointer(HttpAuthorityMetadata()) ==
-      nullptr) {
-    call_args.client_initial_metadata->Set(HttpAuthorityMetadata(),
-                                           default_authority_.Ref());
+  if (md.get_pointer(HttpAuthorityMetadata()) == nullptr) {
+    md.Set(HttpAuthorityMetadata(), filter->default_authority_.Ref());
   }
-  // We have no asynchronous work, so we can just ask the next promise to run,
-  // passing down initial_metadata.
-  return next_promise_factory(std::move(call_args));
 }
 
 const grpc_channel_filter ClientAuthorityFilter::kFilter =
@@ -69,22 +68,21 @@ const grpc_channel_filter ClientAuthorityFilter::kFilter =
         "authority");
 
 namespace {
-bool add_client_authority_filter(ChannelStackBuilder* builder) {
-  if (builder->channel_args()
-          .GetBool(GRPC_ARG_DISABLE_CLIENT_AUTHORITY_FILTER)
-          .value_or(false)) {
-    return true;
-  }
-  builder->PrependFilter(&ClientAuthorityFilter::kFilter);
-  return true;
+bool NeedsClientAuthorityFilter(const ChannelArgs& args) {
+  return !args.GetBool(GRPC_ARG_DISABLE_CLIENT_AUTHORITY_FILTER)
+              .value_or(false);
 }
 }  // namespace
 
 void RegisterClientAuthorityFilter(CoreConfiguration::Builder* builder) {
-  builder->channel_init()->RegisterStage(GRPC_CLIENT_SUBCHANNEL, INT_MAX,
-                                         add_client_authority_filter);
-  builder->channel_init()->RegisterStage(GRPC_CLIENT_DIRECT_CHANNEL, INT_MAX,
-                                         add_client_authority_filter);
+  builder->channel_init()
+      ->RegisterFilter<ClientAuthorityFilter>(GRPC_CLIENT_SUBCHANNEL)
+      .If(NeedsClientAuthorityFilter)
+      .Before<ClientAuthFilter>();
+  builder->channel_init()
+      ->RegisterFilter<ClientAuthorityFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
+      .If(NeedsClientAuthorityFilter)
+      .Before<ClientAuthFilter>();
 }
 
 }  // namespace grpc_core