grpc 1.59.2 → 1.62.0

data/src/core/ext/filters/channel_idle/legacy_channel_idle_filter.h

@@ -0,0 +1,143 @@
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CHANNEL_IDLE_LEGACY_CHANNEL_IDLE_FILTER_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CHANNEL_IDLE_LEGACY_CHANNEL_IDLE_FILTER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+
+#include <grpc/impl/connectivity_state.h>
+
+#include "src/core/ext/filters/channel_idle/idle_filter_state.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/channel/promise_based_filter.h"
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/single_set_ptr.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/arena_promise.h"
+#include "src/core/lib/transport/connectivity_state.h"
+#include "src/core/lib/transport/transport.h"
+
+namespace grpc_core {
+
+class LegacyChannelIdleFilter : public ChannelFilter {
+ public:
+  ~LegacyChannelIdleFilter() override = default;
+
+  LegacyChannelIdleFilter(const LegacyChannelIdleFilter&) = delete;
+  LegacyChannelIdleFilter& operator=(const LegacyChannelIdleFilter&) = delete;
+  LegacyChannelIdleFilter(LegacyChannelIdleFilter&&) = default;
+  LegacyChannelIdleFilter& operator=(LegacyChannelIdleFilter&&) = default;
+
+  // Construct a promise for one call.
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+
+  bool StartTransportOp(grpc_transport_op* op) override;
+
+ protected:
+  using SingleSetActivityPtr =
+      SingleSetPtr<Activity, typename ActivityPtr::deleter_type>;
+
+  LegacyChannelIdleFilter(grpc_channel_stack* channel_stack,
+                          Duration client_idle_timeout)
+      : channel_stack_(channel_stack),
+        client_idle_timeout_(client_idle_timeout) {}
+
+  grpc_channel_stack* channel_stack() { return channel_stack_; };
+
+  virtual void Shutdown();
+  void CloseChannel();
+
+  void IncreaseCallCount();
+  void DecreaseCallCount();
+
+ private:
+  void StartIdleTimer();
+
+  struct CallCountDecreaser {
+    void operator()(LegacyChannelIdleFilter* filter) const {
+      filter->DecreaseCallCount();
+    }
+  };
+
+  // The channel stack to which we take refs for pending callbacks.
+  grpc_channel_stack* channel_stack_;
+  Duration client_idle_timeout_;
+  std::shared_ptr<IdleFilterState> idle_filter_state_{
+      std::make_shared<IdleFilterState>(false)};
+
+  SingleSetActivityPtr activity_;
+};
+
+class LegacyClientIdleFilter final : public LegacyChannelIdleFilter {
+ public:
+  static const grpc_channel_filter kFilter;
+
+  static absl::StatusOr<LegacyClientIdleFilter> Create(
+      const ChannelArgs& args, ChannelFilter::Args filter_args);
+
+ private:
+  using LegacyChannelIdleFilter::LegacyChannelIdleFilter;
+};
+
+class LegacyMaxAgeFilter final : public LegacyChannelIdleFilter {
+ public:
+  static const grpc_channel_filter kFilter;
+  struct Config;
+
+  static absl::StatusOr<LegacyMaxAgeFilter> Create(
+      const ChannelArgs& args, ChannelFilter::Args filter_args);
+
+  void PostInit() override;
+
+ private:
+  class ConnectivityWatcher : public AsyncConnectivityStateWatcherInterface {
+   public:
+    explicit ConnectivityWatcher(LegacyMaxAgeFilter* filter)
+        : channel_stack_(filter->channel_stack()->Ref()), filter_(filter) {}
+    ~ConnectivityWatcher() override = default;
+
+    void OnConnectivityStateChange(grpc_connectivity_state new_state,
+                                   const absl::Status&) override {
+      if (new_state == GRPC_CHANNEL_SHUTDOWN) filter_->Shutdown();
+    }
+
+   private:
+    RefCountedPtr<grpc_channel_stack> channel_stack_;
+    LegacyMaxAgeFilter* filter_;
+  };
+
+  LegacyMaxAgeFilter(grpc_channel_stack* channel_stack,
+                     const Config& max_age_config);
+
+  void Shutdown() override;
+
+  SingleSetActivityPtr max_age_activity_;
+  Duration max_connection_age_;
+  Duration max_connection_age_grace_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CHANNEL_IDLE_LEGACY_CHANNEL_IDLE_FILTER_H

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

@@ -30,8 +30,6 @@
 #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"
@@ -46,13 +47,18 @@
 #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/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/service_config/service_config_call_data.h"
 
 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.h

@@ -38,7 +38,7 @@
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/json/json_args.h"
 #include "src/core/lib/json/json_object_loader.h"
-#include "src/core/lib/service_config/service_config_parser.h"
+#include "src/core/service_config/service_config_parser.h"
 
 // Channel arg key for enabling parsing fault injection via method config.
 #define GRPC_ARG_PARSE_FAULT_INJECTION_METHOD_CONFIG \

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>
@@ -44,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");
@@ -92,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));
@@ -107,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,
@@ -152,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>
 
@@ -32,13 +30,19 @@
 #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

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

@@ -34,16 +34,24 @@
 
 namespace grpc_core {
 
-class ClientAuthorityFilter final : public ChannelFilter {
+class ClientAuthorityFilter final
+    : public ImplementChannelFilter<ClientAuthorityFilter> {
  public:
   static const grpc_channel_filter kFilter;
 
   static absl::StatusOr<ClientAuthorityFilter> Create(const ChannelArgs& args,
                                                       ChannelFilter::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,
+                                 ClientAuthorityFilter* filter);
+    static const NoInterceptor OnServerInitialMetadata;
+    static const NoInterceptor OnServerTrailingMetadata;
+    static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnServerToClientMessage;
+    static const NoInterceptor OnFinalize;
+  };
 
  private:
   explicit ClientAuthorityFilter(Slice default_authority)