grpc 1.60.0 → 1.61.0

data/src/core/ext/filters/client_channel/resolver/xds/{xds_resolver.h → xds_resolver_attributes.h}

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_XDS_XDS_RESOLVER_H
-#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_XDS_XDS_RESOLVER_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_XDS_XDS_RESOLVER_ATTRIBUTES_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_XDS_XDS_RESOLVER_ATTRIBUTES_H
 
 #include <grpc/support/port_platform.h>
 
@@ -49,13 +49,14 @@ class XdsRouteStateAttribute
     : public ServiceConfigCallData::CallAttributeInterface {
  public:
   static UniqueTypeName TypeName() {
-    static UniqueTypeName::Factory factory("xds_cluster_lb_data");
+    static UniqueTypeName::Factory factory("xds_route_state");
     return factory.Create();
   }
 
   virtual bool HasClusterForRoute(absl::string_view cluster_name) const = 0;
   UniqueTypeName type() const override { return TypeName(); }
 };
+
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_XDS_XDS_RESOLVER_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_XDS_XDS_RESOLVER_ATTRIBUTES_H

data/src/core/ext/filters/client_channel/resolver/xds/xds_resolver_trace.cc

@@ -0,0 +1,25 @@
+//
+// Copyright 2019 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.
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/client_channel/resolver/xds/xds_resolver_trace.h"
+
+namespace grpc_core {
+
+TraceFlag grpc_xds_resolver_trace(false, "xds_resolver");
+
+}  // namespace grpc_core

data/src/core/ext/filters/client_channel/resolver/xds/xds_resolver_trace.h

@@ -0,0 +1,30 @@
+//
+// Copyright 2019 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_CLIENT_CHANNEL_RESOLVER_XDS_XDS_RESOLVER_TRACE_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_XDS_XDS_RESOLVER_TRACE_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/debug/trace.h"
+
+namespace grpc_core {
+
+extern TraceFlag grpc_xds_resolver_trace;
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_XDS_XDS_RESOLVER_TRACE_H

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

@@ -143,6 +143,7 @@ const RetryMethodConfig* RetryFilter::GetRetryPolicy(
 const grpc_channel_filter RetryFilter::kVtable = {
     RetryFilter::LegacyCallData::StartTransportStreamOpBatch,
     nullptr,
+    /* init_call: */ nullptr,
     RetryFilter::StartTransportOp,
     sizeof(RetryFilter::LegacyCallData),
     RetryFilter::LegacyCallData::Init,

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

@@ -54,8 +54,11 @@ namespace grpc_core {
 
 namespace {
 
-class ServiceConfigChannelArgFilter : public ChannelFilter {
+class ServiceConfigChannelArgFilter
+    : public ImplementChannelFilter<ServiceConfigChannelArgFilter> {
  public:
+  static const grpc_channel_filter kFilter;
+
   static absl::StatusOr<ServiceConfigChannelArgFilter> Create(
       const ChannelArgs& args, ChannelFilter::Args) {
     return ServiceConfigChannelArgFilter(args);
@@ -74,31 +77,46 @@ class ServiceConfigChannelArgFilter : public ChannelFilter {
     }
   }
 
-  // Construct a promise for one call.
-  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
-      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+  class Call {
+   public:
+    void OnClientInitialMetadata(ClientMetadata& md,
+                                 ServiceConfigChannelArgFilter* filter);
+    static const NoInterceptor OnServerInitialMetadata;
+    static const NoInterceptor OnServerTrailingMetadata;
+    static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnServerToClientMessage;
+    static const NoInterceptor OnFinalize;
+  };
 
  private:
   RefCountedPtr<ServiceConfig> service_config_;
 };
 
-ArenaPromise<ServerMetadataHandle>
-ServiceConfigChannelArgFilter::MakeCallPromise(
-    CallArgs call_args, NextPromiseFactory next_promise_factory) {
+const NoInterceptor
+    ServiceConfigChannelArgFilter::Call::OnServerInitialMetadata;
+const NoInterceptor
+    ServiceConfigChannelArgFilter::Call::OnServerTrailingMetadata;
+const NoInterceptor
+    ServiceConfigChannelArgFilter::Call::OnClientToServerMessage;
+const NoInterceptor
+    ServiceConfigChannelArgFilter::Call::OnServerToClientMessage;
+const NoInterceptor ServiceConfigChannelArgFilter::Call::OnFinalize;
+
+void ServiceConfigChannelArgFilter::Call::OnClientInitialMetadata(
+    ClientMetadata& md, ServiceConfigChannelArgFilter* filter) {
   const ServiceConfigParser::ParsedConfigVector* method_configs = nullptr;
-  if (service_config_ != nullptr) {
-    method_configs = service_config_->GetMethodParsedConfigVector(
-        call_args.client_initial_metadata->get_pointer(HttpPathMetadata())
-            ->c_slice());
+  if (filter->service_config_ != nullptr) {
+    method_configs = filter->service_config_->GetMethodParsedConfigVector(
+        md.get_pointer(HttpPathMetadata())->c_slice());
   }
   auto* arena = GetContext<Arena>();
   auto* service_config_call_data = arena->New<ServiceConfigCallData>(
       arena, GetContext<grpc_call_context_element>());
-  service_config_call_data->SetServiceConfig(service_config_, method_configs);
-  return next_promise_factory(std::move(call_args));
+  service_config_call_data->SetServiceConfig(filter->service_config_,
+                                             method_configs);
 }
 
-const grpc_channel_filter kServiceConfigChannelArgFilter =
+const grpc_channel_filter ServiceConfigChannelArgFilter::kFilter =
     MakePromiseBasedFilter<ServiceConfigChannelArgFilter,
                            FilterEndpoint::kClient>(
         "service_config_channel_arg");
@@ -108,11 +126,11 @@ const grpc_channel_filter kServiceConfigChannelArgFilter =
 void RegisterServiceConfigChannelArgFilter(
     CoreConfiguration::Builder* builder) {
   builder->channel_init()
-      ->RegisterFilter(GRPC_CLIENT_DIRECT_CHANNEL,
-                       &kServiceConfigChannelArgFilter)
+      ->RegisterFilter<ServiceConfigChannelArgFilter>(
+          GRPC_CLIENT_DIRECT_CHANNEL)
       .ExcludeFromMinimalStack()
       .IfHasChannelArg(GRPC_ARG_SERVICE_CONFIG)
-      .Before({&ClientMessageSizeFilter::kFilter});
+      .Before<ClientMessageSizeFilter>();
 }
 
 }  // namespace grpc_core

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

@@ -343,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,
@@ -368,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,

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

@@ -54,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 {
 
@@ -144,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*>(
@@ -188,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(
@@ -205,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/http/client/http_client_filter.cc

@@ -51,6 +51,10 @@
 
 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");
@@ -105,40 +109,27 @@ Slice UserAgentFromArgs(const ChannelArgs& args,
 }
 }  // 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,

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

@@ -37,6 +37,12 @@
 
 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 =
@@ -49,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 =
@@ -75,14 +76,13 @@ bool NeedsClientAuthorityFilter(const ChannelArgs& args) {
 
 void RegisterClientAuthorityFilter(CoreConfiguration::Builder* builder) {
   builder->channel_init()
-      ->RegisterFilter(GRPC_CLIENT_SUBCHANNEL, &ClientAuthorityFilter::kFilter)
+      ->RegisterFilter<ClientAuthorityFilter>(GRPC_CLIENT_SUBCHANNEL)
       .If(NeedsClientAuthorityFilter)
-      .Before({&ClientAuthFilter::kFilter});
+      .Before<ClientAuthFilter>();
   builder->channel_init()
-      ->RegisterFilter(GRPC_CLIENT_DIRECT_CHANNEL,
-                       &ClientAuthorityFilter::kFilter)
+      ->RegisterFilter<ClientAuthorityFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
       .If(NeedsClientAuthorityFilter)
-      .Before({&ClientAuthFilter::kFilter});
+      .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)

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

@@ -22,10 +22,12 @@
 
 #include "src/core/ext/filters/http/client/http_client_filter.h"
 #include "src/core/ext/filters/http/message_compress/compression_filter.h"
+#include "src/core/ext/filters/http/message_compress/legacy_compression_filter.h"
 #include "src/core/ext/filters/http/server/http_server_filter.h"
 #include "src/core/ext/filters/message_size/message_size_filter.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/transport.h"
 
@@ -38,31 +40,51 @@ bool IsBuildingHttpLikeTransport(const ChannelArgs& args) {
 }  // namespace
 
 void RegisterHttpFilters(CoreConfiguration::Builder* builder) {
+  if (IsV3CompressionFilterEnabled()) {
+    builder->channel_init()
+        ->RegisterFilter<ClientCompressionFilter>(GRPC_CLIENT_SUBCHANNEL)
+        .If(IsBuildingHttpLikeTransport)
+        .After<HttpClientFilter>()
+        .After<ClientMessageSizeFilter>();
+    builder->channel_init()
+        ->RegisterFilter<ClientCompressionFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
+        .If(IsBuildingHttpLikeTransport)
+        .After<HttpClientFilter>()
+        .After<ClientMessageSizeFilter>();
+    builder->channel_init()
+        ->RegisterFilter<ServerCompressionFilter>(GRPC_SERVER_CHANNEL)
+        .If(IsBuildingHttpLikeTransport)
+        .After<HttpServerFilter>()
+        .After<ServerMessageSizeFilter>();
+  } else {
+    builder->channel_init()
+        ->RegisterFilter<LegacyClientCompressionFilter>(GRPC_CLIENT_SUBCHANNEL)
+        .If(IsBuildingHttpLikeTransport)
+        .After<HttpClientFilter>()
+        .After<ClientMessageSizeFilter>();
+    builder->channel_init()
+        ->RegisterFilter<LegacyClientCompressionFilter>(
+            GRPC_CLIENT_DIRECT_CHANNEL)
+        .If(IsBuildingHttpLikeTransport)
+        .After<HttpClientFilter>()
+        .After<ClientMessageSizeFilter>();
+    builder->channel_init()
+        ->RegisterFilter<LegacyServerCompressionFilter>(GRPC_SERVER_CHANNEL)
+        .If(IsBuildingHttpLikeTransport)
+        .After<HttpServerFilter>()
+        .After<ServerMessageSizeFilter>();
+  }
   builder->channel_init()
-      ->RegisterFilter(GRPC_CLIENT_SUBCHANNEL,
-                       &ClientCompressionFilter::kFilter)
+      ->RegisterFilter<HttpClientFilter>(GRPC_CLIENT_SUBCHANNEL)
       .If(IsBuildingHttpLikeTransport)
-      .After({&HttpClientFilter::kFilter, &ClientMessageSizeFilter::kFilter});
+      .After<ClientMessageSizeFilter>();
   builder->channel_init()
-      ->RegisterFilter(GRPC_CLIENT_DIRECT_CHANNEL,
-                       &ClientCompressionFilter::kFilter)
+      ->RegisterFilter<HttpClientFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
       .If(IsBuildingHttpLikeTransport)
-      .After({&HttpClientFilter::kFilter, &ClientMessageSizeFilter::kFilter});
+      .After<ClientMessageSizeFilter>();
   builder->channel_init()
-      ->RegisterFilter(GRPC_SERVER_CHANNEL, &ServerCompressionFilter::kFilter)
+      ->RegisterFilter<HttpServerFilter>(GRPC_SERVER_CHANNEL)
       .If(IsBuildingHttpLikeTransport)
-      .After({&HttpServerFilter::kFilter, &ServerMessageSizeFilter::kFilter});
-  builder->channel_init()
-      ->RegisterFilter(GRPC_CLIENT_SUBCHANNEL, &HttpClientFilter::kFilter)
-      .If(IsBuildingHttpLikeTransport)
-      .After({&ClientMessageSizeFilter::kFilter});
-  builder->channel_init()
-      ->RegisterFilter(GRPC_CLIENT_DIRECT_CHANNEL, &HttpClientFilter::kFilter)
-      .If(IsBuildingHttpLikeTransport)
-      .After({&ClientMessageSizeFilter::kFilter});
-  builder->channel_init()
-      ->RegisterFilter(GRPC_SERVER_CHANNEL, &HttpServerFilter::kFilter)
-      .If(IsBuildingHttpLikeTransport)
-      .After({&ServerMessageSizeFilter::kFilter});
+      .After<ServerMessageSizeFilter>();
 }
 }  // namespace grpc_core