grpc 1.42.0 → 1.43.1

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

@@ -104,10 +104,10 @@ class RegistryState {
   // hurting performance (which is unlikely, since these allocations
   // only occur at gRPC initialization time).
   absl::InlinedVector<std::unique_ptr<ResolverFactory>, 10> factories_;
-  grpc_core::UniquePtr<char> default_prefix_;
+  UniquePtr<char> default_prefix_;
 };
 
-static RegistryState* g_state = nullptr;
+RegistryState* g_state = nullptr;
 
 }  // namespace
 
@@ -181,15 +181,14 @@ std::string ResolverRegistry::GetDefaultAuthority(absl::string_view target) {
   return authority;
 }
 
-grpc_core::UniquePtr<char> ResolverRegistry::AddDefaultPrefixIfNeeded(
-    const char* target) {
+UniquePtr<char> ResolverRegistry::AddDefaultPrefixIfNeeded(const char* target) {
   GPR_ASSERT(g_state != nullptr);
   URI uri;
   std::string canonical_target;
   g_state->FindResolverFactory(target, &uri, &canonical_target);
-  return grpc_core::UniquePtr<char>(canonical_target.empty()
-                                        ? gpr_strdup(target)
-                                        : gpr_strdup(canonical_target.c_str()));
+  return UniquePtr<char>(canonical_target.empty()
+                             ? gpr_strdup(target)
+                             : gpr_strdup(canonical_target.c_str()));
 }
 
 }  // namespace grpc_core

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

@@ -76,8 +76,7 @@ class ResolverRegistry {
   static std::string GetDefaultAuthority(absl::string_view target);
 
   /// Returns \a target with the default prefix prepended, if needed.
-  static grpc_core::UniquePtr<char> AddDefaultPrefixIfNeeded(
-      const char* target);
+  static UniquePtr<char> AddDefaultPrefixIfNeeded(const char* target);
 
   /// Returns the resolver factory for \a scheme.
   /// Caller does NOT own the return value.

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

@@ -188,8 +188,8 @@ RefCountedPtr<SubchannelCall> SubchannelCall::Ref() {
   return RefCountedPtr<SubchannelCall>(this);
 }
 
-RefCountedPtr<SubchannelCall> SubchannelCall::Ref(
-    const grpc_core::DebugLocation& location, const char* reason) {
+RefCountedPtr<SubchannelCall> SubchannelCall::Ref(const DebugLocation& location,
+                                                  const char* reason) {
   IncrementRefCount(location, reason);
   return RefCountedPtr<SubchannelCall>(this);
 }
@@ -287,8 +287,8 @@ void SubchannelCall::IncrementRefCount() {
   GRPC_CALL_STACK_REF(SUBCHANNEL_CALL_TO_CALL_STACK(this), "");
 }
 
-void SubchannelCall::IncrementRefCount(
-    const grpc_core::DebugLocation& /*location*/, const char* reason) {
+void SubchannelCall::IncrementRefCount(const DebugLocation& /*location*/,
+                                       const char* reason) {
   GRPC_CALL_STACK_REF(SUBCHANNEL_CALL_TO_CALL_STACK(this), reason);
 }
 

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

@@ -495,7 +495,7 @@ extern const grpc_channel_filter FaultInjectionFilterVtable = {
 };
 
 void FaultInjectionFilterInit(void) {
-  grpc_core::FaultInjectionServiceConfigParser::Register();
+  FaultInjectionServiceConfigParser::Register();
 }
 
 void FaultInjectionFilterShutdown(void) {}

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

@@ -79,7 +79,6 @@ struct call_data {
   grpc_linked_mdelem method;
   grpc_linked_mdelem scheme;
   grpc_linked_mdelem content_type;
-  grpc_linked_mdelem user_agent;
   // State for handling recv_initial_metadata ops.
   grpc_metadata_batch* recv_initial_metadata;
   grpc_error_handle recv_initial_metadata_error = GRPC_ERROR_NONE;
@@ -104,7 +103,7 @@ struct call_data {
 
 struct channel_data {
   grpc_mdelem static_scheme;
-  grpc_mdelem user_agent;
+  grpc_core::Slice user_agent;
   size_t max_payload_size_for_get;
 };
 }  // namespace
@@ -139,17 +138,10 @@ static grpc_error_handle client_filter_incoming_metadata(
     }
   }
 
-  if (b->legacy_index()->named.grpc_message != nullptr) {
-    grpc_slice pct_decoded_msg = grpc_core::PermissivePercentDecodeSlice(
-        GRPC_MDVALUE(b->legacy_index()->named.grpc_message->md));
-    if (grpc_slice_is_equivalent(
-            pct_decoded_msg,
-            GRPC_MDVALUE(b->legacy_index()->named.grpc_message->md))) {
-      grpc_slice_unref_internal(pct_decoded_msg);
-    } else {
-      grpc_metadata_batch_set_value(b->legacy_index()->named.grpc_message,
-                                    pct_decoded_msg);
-    }
+  if (grpc_core::Slice* grpc_message =
+          b->get_pointer(grpc_core::GrpcMessageMetadata())) {
+    *grpc_message =
+        grpc_core::PermissivePercentDecodeSlice(std::move(*grpc_message));
   }
 
   if (b->legacy_index()->named.content_type != nullptr) {
@@ -445,9 +437,6 @@ static void http_client_start_transport_stream_op_batch(
     remove_if_present(
         batch->payload->send_initial_metadata.send_initial_metadata,
         GRPC_BATCH_CONTENT_TYPE);
-    remove_if_present(
-        batch->payload->send_initial_metadata.send_initial_metadata,
-        GRPC_BATCH_USER_AGENT);
 
     /* Send : prefixed headers, which have to be before any application
        layer headers. */
@@ -466,11 +455,8 @@ static void http_client_start_transport_stream_op_batch(
         &calld->content_type, GRPC_MDELEM_CONTENT_TYPE_APPLICATION_SLASH_GRPC,
         GRPC_BATCH_CONTENT_TYPE);
     if (error != GRPC_ERROR_NONE) goto done;
-    error = grpc_metadata_batch_add_tail(
-        batch->payload->send_initial_metadata.send_initial_metadata,
-        &calld->user_agent, GRPC_MDELEM_REF(channeld->user_agent),
-        GRPC_BATCH_USER_AGENT);
-    if (error != GRPC_ERROR_NONE) goto done;
+    batch->payload->send_initial_metadata.send_initial_metadata->Set(
+        grpc_core::UserAgentMetadata(), channeld->user_agent.Ref());
   }
 
 done:
@@ -534,8 +520,8 @@ static size_t max_payload_size_from_args(const grpc_channel_args* args) {
   return kMaxPayloadSizeForGet;
 }
 
-static grpc_core::ManagedMemorySlice user_agent_from_args(
-    const grpc_channel_args* args, const char* transport_name) {
+static grpc_core::Slice user_agent_from_args(const grpc_channel_args* args,
+                                             const char* transport_name) {
   std::vector<std::string> user_agent_fields;
 
   for (size_t i = 0; args && i < args->num_args; i++) {
@@ -565,29 +551,27 @@ static grpc_core::ManagedMemorySlice user_agent_from_args(
   }
 
   std::string user_agent_string = absl::StrJoin(user_agent_fields, " ");
-  return grpc_core::ManagedMemorySlice(user_agent_string.c_str());
+  return grpc_core::Slice::FromCopiedString(user_agent_string.c_str());
 }
 
 /* Constructor for channel_data */
 static grpc_error_handle http_client_init_channel_elem(
     grpc_channel_element* elem, grpc_channel_element_args* args) {
   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);
   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_mdelem_from_slices(
-      GRPC_MDSTR_USER_AGENT,
-      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, args->optional_transport->vtable->name));
   return GRPC_ERROR_NONE;
 }
 
 /* Destructor for channel data */
 static void http_client_destroy_channel_elem(grpc_channel_element* elem) {
-  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  GRPC_MDELEM_UNREF(chand->user_agent);
+  static_cast<channel_data*>(elem->channel_data)->~channel_data();
 }
 
 const grpc_channel_filter grpc_http_client_filter = {

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

@@ -76,13 +76,11 @@ void RegisterHttpFilters(CoreConfiguration::Builder* builder) {
   optional(GRPC_SERVER_CHANNEL, false, GRPC_ARG_ENABLE_PER_MESSAGE_COMPRESSION,
            &grpc_message_compress_filter);
   optional(GRPC_CLIENT_SUBCHANNEL, true,
-           GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION,
-           &grpc_core::MessageDecompressFilter);
+           GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION, &MessageDecompressFilter);
   optional(GRPC_CLIENT_DIRECT_CHANNEL, true,
-           GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION,
-           &grpc_core::MessageDecompressFilter);
+           GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION, &MessageDecompressFilter);
   optional(GRPC_SERVER_CHANNEL, true, GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION,
-           &grpc_core::MessageDecompressFilter);
+           &MessageDecompressFilter);
   required(GRPC_CLIENT_SUBCHANNEL, &grpc_http_client_filter);
   required(GRPC_CLIENT_DIRECT_CHANNEL, &grpc_http_client_filter);
   required(GRPC_SERVER_CHANNEL, &grpc_http_server_filter);

data/src/core/ext/filters/http/server/http_server_filter.cc

@@ -104,18 +104,10 @@ struct channel_data {
 }  // namespace
 
 static grpc_error_handle hs_filter_outgoing_metadata(grpc_metadata_batch* b) {
-  if (b->legacy_index()->named.grpc_message != nullptr) {
-    grpc_slice pct_encoded_msg = grpc_core::PercentEncodeSlice(
-        GRPC_MDVALUE(b->legacy_index()->named.grpc_message->md),
-        grpc_core::PercentEncodingType::Compatible);
-    if (grpc_slice_is_equivalent(
-            pct_encoded_msg,
-            GRPC_MDVALUE(b->legacy_index()->named.grpc_message->md))) {
-      grpc_slice_unref_internal(pct_encoded_msg);
-    } else {
-      grpc_metadata_batch_set_value(b->legacy_index()->named.grpc_message,
-                                    pct_encoded_msg);
-    }
+  if (grpc_core::Slice* grpc_message =
+          b->get_pointer(grpc_core::GrpcMessageMetadata())) {
+    *grpc_message = grpc_core::PercentEncodeSlice(
+        std::move(*grpc_message), grpc_core::PercentEncodingType::Compatible);
   }
   return GRPC_ERROR_NONE;
 }
@@ -306,19 +298,11 @@ static grpc_error_handle hs_filter_incoming_metadata(grpc_call_element* elem,
     }
   }
 
-  if (b->legacy_index()->named.host != nullptr &&
-      b->legacy_index()->named.authority == nullptr) {
-    grpc_linked_mdelem* el = b->legacy_index()->named.host;
-    grpc_mdelem md = GRPC_MDELEM_REF(el->md);
-    b->Remove(el);
-    hs_add_error(
-        error_name, &error,
-        grpc_metadata_batch_add_head(
-            b, el,
-            grpc_mdelem_from_slices(GRPC_MDSTR_AUTHORITY,
-                                    grpc_slice_ref_internal(GRPC_MDVALUE(md))),
-            GRPC_BATCH_AUTHORITY));
-    GRPC_MDELEM_UNREF(md);
+  if (b->legacy_index()->named.authority == nullptr) {
+    absl::optional<grpc_core::Slice> host = b->Take(grpc_core::HostMetadata());
+    if (host.has_value()) {
+      b->Append(":authority", std::move(*host));
+    }
   }
 
   if (b->legacy_index()->named.authority == nullptr) {
@@ -329,9 +313,8 @@ static grpc_error_handle hs_filter_incoming_metadata(grpc_call_element* elem,
   }
 
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  if (!chand->surface_user_agent &&
-      b->legacy_index()->named.user_agent != nullptr) {
-    b->Remove(GRPC_BATCH_USER_AGENT);
+  if (!chand->surface_user_agent) {
+    b->Remove(grpc_core::UserAgentMetadata());
   }
 
   return error;

data/src/core/ext/filters/server_config_selector/server_config_selector.cc

@@ -0,0 +1,67 @@
+//
+// Copyright 2021 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/server_config_selector/server_config_selector.h"
+
+#include "src/core/lib/channel/channel_args.h"
+
+namespace grpc_core {
+namespace {
+
+void* ServerConfigSelectorProviderArgCopy(void* p) {
+  ServerConfigSelectorProvider* arg =
+      static_cast<ServerConfigSelectorProvider*>(p);
+  return arg->Ref().release();
+}
+
+void ServerConfigSelectorProviderArgDestroy(void* p) {
+  ServerConfigSelectorProvider* arg =
+      static_cast<ServerConfigSelectorProvider*>(p);
+  arg->Unref();
+}
+
+int ServerConfigSelectorProviderArgCmp(void* p, void* q) {
+  return QsortCompare(p, q);
+}
+
+const grpc_arg_pointer_vtable kChannelArgVtable = {
+    ServerConfigSelectorProviderArgCopy, ServerConfigSelectorProviderArgDestroy,
+    ServerConfigSelectorProviderArgCmp};
+
+const char* kServerConfigSelectorProviderChannelArgName =
+    "grpc.internal.server_config_selector_provider";
+
+}  // namespace
+
+grpc_arg ServerConfigSelectorProvider::MakeChannelArg() const {
+  return grpc_channel_arg_pointer_create(
+      const_cast<char*>(kServerConfigSelectorProviderChannelArgName),
+      const_cast<ServerConfigSelectorProvider*>(this), &kChannelArgVtable);
+}
+
+RefCountedPtr<ServerConfigSelectorProvider>
+ServerConfigSelectorProvider::GetFromChannelArgs(
+    const grpc_channel_args& args) {
+  ServerConfigSelectorProvider* config_selector_provider =
+      grpc_channel_args_find_pointer<ServerConfigSelectorProvider>(
+          &args, kServerConfigSelectorProviderChannelArgName);
+  return config_selector_provider != nullptr ? config_selector_provider->Ref()
+                                             : nullptr;
+}
+
+}  // namespace grpc_core

data/src/core/ext/filters/server_config_selector/server_config_selector.h

@@ -0,0 +1,70 @@
+//
+// Copyright 2021 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_CORE_EXT_FILTERS_SERVER_CONFIG_SELECTOR_SERVER_CONFIG_SELECTOR_H
+#define GRPC_CORE_EXT_FILTERS_SERVER_CONFIG_SELECTOR_SERVER_CONFIG_SELECTOR_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/status/statusor.h"
+
+#include "src/core/ext/service_config/service_config.h"
+#include "src/core/lib/transport/metadata_batch.h"
+
+namespace grpc_core {
+
+// ServerConfigSelector allows for choosing the service config to apply to a
+// server-side call based on the received initial metadata.
+class ServerConfigSelector : public RefCounted<ServerConfigSelector> {
+ public:
+  // Configuration to apply to an incoming call
+  struct CallConfig {
+    grpc_error_handle error = GRPC_ERROR_NONE;
+    const ServiceConfigParser::ParsedConfigVector* method_configs = nullptr;
+    RefCountedPtr<ServiceConfig> service_config;
+  };
+
+  ~ServerConfigSelector() override = default;
+  // Returns the CallConfig to apply to a call based on the incoming \a metadata
+  virtual CallConfig GetCallConfig(grpc_metadata_batch* metadata) = 0;
+};
+
+// ServerConfigSelectorProvider allows for subscribers to watch for updates on
+// ServerConfigSelector. It is propagated via channel args.
+class ServerConfigSelectorProvider
+    : public RefCounted<ServerConfigSelectorProvider> {
+ public:
+  class ServerConfigSelectorWatcher {
+   public:
+    virtual ~ServerConfigSelectorWatcher() = default;
+    virtual void OnServerConfigSelectorUpdate(
+        absl::StatusOr<RefCountedPtr<ServerConfigSelector>> update) = 0;
+  };
+
+  ~ServerConfigSelectorProvider() override = default;
+  // Only a single watcher is allowed at present
+  virtual absl::StatusOr<RefCountedPtr<ServerConfigSelector>> Watch(
+      std::unique_ptr<ServerConfigSelectorWatcher> watcher) = 0;
+  virtual void CancelWatch() = 0;
+
+  grpc_arg MakeChannelArg() const;
+  static RefCountedPtr<ServerConfigSelectorProvider> GetFromChannelArgs(
+      const grpc_channel_args& args);
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_FILTERS_SERVER_CONFIG_SELECTOR_SERVER_CONFIG_SELECTOR_H

data/src/core/ext/filters/server_config_selector/server_config_selector_filter.cc

@@ -0,0 +1,265 @@
+//
+//
+// Copyright 2021 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/server_config_selector/server_config_selector_filter.h"
+
+#include "src/core/ext/filters/server_config_selector/server_config_selector.h"
+#include "src/core/ext/service_config/service_config_call_data.h"
+#include "src/core/lib/transport/error_utils.h"
+
+namespace grpc_core {
+
+namespace {
+
+class ChannelData {
+ public:
+  static grpc_error_handle Init(grpc_channel_element* elem,
+                                grpc_channel_element_args* args);
+  static void Destroy(grpc_channel_element* elem);
+
+  absl::StatusOr<RefCountedPtr<ServerConfigSelector>> config_selector() {
+    MutexLock lock(&mu_);
+    return config_selector_;
+  }
+
+ private:
+  class ServerConfigSelectorWatcher
+      : public ServerConfigSelectorProvider::ServerConfigSelectorWatcher {
+   public:
+    explicit ServerConfigSelectorWatcher(ChannelData* chand) : chand_(chand) {}
+    void OnServerConfigSelectorUpdate(
+        absl::StatusOr<RefCountedPtr<ServerConfigSelector>> update) override {
+      MutexLock lock(&chand_->mu_);
+      chand_->config_selector_ = std::move(update);
+    }
+
+   private:
+    ChannelData* chand_;
+  };
+
+  explicit ChannelData(RefCountedPtr<ServerConfigSelectorProvider>
+                           server_config_selector_provider);
+  ~ChannelData();
+
+  RefCountedPtr<ServerConfigSelectorProvider> server_config_selector_provider_;
+  Mutex mu_;
+  absl::StatusOr<RefCountedPtr<ServerConfigSelector>> config_selector_
+      ABSL_GUARDED_BY(mu_);
+};
+
+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 */);
+  static void StartTransportStreamOpBatch(grpc_call_element* elem,
+                                          grpc_transport_stream_op_batch* op);
+
+ private:
+  CallData(grpc_call_element* elem, const grpc_call_element_args& args);
+  ~CallData();
+  static void RecvInitialMetadataReady(void* user_data,
+                                       grpc_error_handle error);
+  static void RecvTrailingMetadataReady(void* user_data,
+                                        grpc_error_handle error);
+  void MaybeResumeRecvTrailingMetadataReady();
+
+  grpc_call_context_element* call_context_;
+  CallCombiner* call_combiner_;
+  ServiceConfigCallData service_config_call_data_;
+  // Overall error for the call
+  grpc_error_handle error_ = GRPC_ERROR_NONE;
+  // State for keeping track of recv_initial_metadata
+  grpc_metadata_batch* recv_initial_metadata_ = nullptr;
+  grpc_closure* original_recv_initial_metadata_ready_ = nullptr;
+  grpc_closure recv_initial_metadata_ready_;
+  // State for keeping of track of recv_trailing_metadata
+  grpc_closure* original_recv_trailing_metadata_ready_;
+  grpc_closure recv_trailing_metadata_ready_;
+  grpc_error_handle recv_trailing_metadata_ready_error_;
+  bool seen_recv_trailing_metadata_ready_ = false;
+};
+
+// ChannelData
+
+grpc_error_handle ChannelData::Init(grpc_channel_element* elem,
+                                    grpc_channel_element_args* args) {
+  GPR_ASSERT(elem->filter = &kServerConfigSelectorFilter);
+  RefCountedPtr<ServerConfigSelectorProvider> server_config_selector_provider =
+      ServerConfigSelectorProvider::GetFromChannelArgs(*args->channel_args);
+  if (server_config_selector_provider == nullptr) {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "No ServerConfigSelectorProvider object found");
+  }
+  new (elem->channel_data)
+      ChannelData(std::move(server_config_selector_provider));
+  return GRPC_ERROR_NONE;
+}
+
+void ChannelData::Destroy(grpc_channel_element* elem) {
+  auto* chand = static_cast<ChannelData*>(elem->channel_data);
+  chand->~ChannelData();
+}
+
+ChannelData::ChannelData(
+    RefCountedPtr<ServerConfigSelectorProvider> server_config_selector_provider)
+    : server_config_selector_provider_(
+          std::move(server_config_selector_provider)) {
+  GPR_ASSERT(server_config_selector_provider_ != nullptr);
+  auto server_config_selector_watcher =
+      absl::make_unique<ServerConfigSelectorWatcher>(this);
+  config_selector_ = server_config_selector_provider_->Watch(
+      std::move(server_config_selector_watcher));
+}
+
+ChannelData::~ChannelData() { server_config_selector_provider_->CancelWatch(); }
+
+// CallData
+
+grpc_error_handle CallData::Init(grpc_call_element* elem,
+                                 const grpc_call_element_args* args) {
+  new (elem->call_data) CallData(elem, *args);
+  return GRPC_ERROR_NONE;
+}
+
+void CallData::Destroy(grpc_call_element* elem,
+                       const grpc_call_final_info* /*final_info*/,
+                       grpc_closure* /*then_schedule_closure*/) {
+  auto* calld = static_cast<CallData*>(elem->call_data);
+  calld->~CallData();
+}
+
+void CallData::StartTransportStreamOpBatch(grpc_call_element* elem,
+                                           grpc_transport_stream_op_batch* op) {
+  CallData* calld = static_cast<CallData*>(elem->call_data);
+  if (op->recv_initial_metadata) {
+    calld->recv_initial_metadata_ =
+        op->payload->recv_initial_metadata.recv_initial_metadata;
+    calld->original_recv_initial_metadata_ready_ =
+        op->payload->recv_initial_metadata.recv_initial_metadata_ready;
+    op->payload->recv_initial_metadata.recv_initial_metadata_ready =
+        &calld->recv_initial_metadata_ready_;
+  }
+  if (op->recv_trailing_metadata) {
+    // We might generate errors on receiving initial metadata which we need to
+    // bubble up through recv_trailing_metadata_ready
+    calld->original_recv_trailing_metadata_ready_ =
+        op->payload->recv_trailing_metadata.recv_trailing_metadata_ready;
+    op->payload->recv_trailing_metadata.recv_trailing_metadata_ready =
+        &calld->recv_trailing_metadata_ready_;
+  }
+  // Chain to the next filter.
+  grpc_call_next_op(elem, op);
+}
+
+CallData::CallData(grpc_call_element* elem, const grpc_call_element_args& args)
+    : call_context_(args.context), call_combiner_(args.call_combiner) {
+  GRPC_CLOSURE_INIT(&recv_initial_metadata_ready_, RecvInitialMetadataReady,
+                    elem, grpc_schedule_on_exec_ctx);
+  GRPC_CLOSURE_INIT(&recv_trailing_metadata_ready_, RecvTrailingMetadataReady,
+                    elem, grpc_schedule_on_exec_ctx);
+}
+
+CallData::~CallData() {
+  // Remove the entry from call context, just in case anyone above us
+  // tries to look at it during call stack destruction.
+  call_context_[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value = nullptr;
+  GRPC_ERROR_UNREF(error_);
+}
+
+void CallData::RecvInitialMetadataReady(void* user_data,
+                                        grpc_error_handle error) {
+  grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
+  CallData* calld = static_cast<CallData*>(elem->call_data);
+  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
+  if (error == GRPC_ERROR_NONE) {
+    auto config_selector = chand->config_selector();
+    if (config_selector.ok()) {
+      auto call_config =
+          config_selector.value()->GetCallConfig(calld->recv_initial_metadata_);
+      if (call_config.error != GRPC_ERROR_NONE) {
+        calld->error_ = call_config.error;
+        error = call_config.error;  // Does not take a ref
+      } else {
+        calld->service_config_call_data_ =
+            ServiceConfigCallData(std::move(call_config.service_config),
+                                  call_config.method_configs, {});
+        calld->call_context_[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value =
+            &calld->service_config_call_data_;
+      }
+    } else {
+      calld->error_ = absl_status_to_grpc_error(config_selector.status());
+      error = calld->error_;
+    }
+  }
+  calld->MaybeResumeRecvTrailingMetadataReady();
+  grpc_closure* closure = calld->original_recv_initial_metadata_ready_;
+  calld->original_recv_initial_metadata_ready_ = nullptr;
+  Closure::Run(DEBUG_LOCATION, closure, GRPC_ERROR_REF(error));
+}
+
+void CallData::RecvTrailingMetadataReady(void* user_data,
+                                         grpc_error_handle error) {
+  grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
+  CallData* calld = static_cast<CallData*>(elem->call_data);
+  if (calld->original_recv_initial_metadata_ready_ != nullptr) {
+    calld->seen_recv_trailing_metadata_ready_ = true;
+    calld->recv_trailing_metadata_ready_error_ = GRPC_ERROR_REF(error);
+    GRPC_CALL_COMBINER_STOP(calld->call_combiner_,
+                            "Deferring RecvTrailingMetadataReady until after "
+                            "RecvInitialMetadataReady");
+    return;
+  }
+  error = grpc_error_add_child(GRPC_ERROR_REF(error), calld->error_);
+  calld->error_ = GRPC_ERROR_NONE;
+  grpc_closure* closure = calld->original_recv_trailing_metadata_ready_;
+  calld->original_recv_trailing_metadata_ready_ = nullptr;
+  Closure::Run(DEBUG_LOCATION, closure, error);
+}
+
+void CallData::MaybeResumeRecvTrailingMetadataReady() {
+  if (seen_recv_trailing_metadata_ready_) {
+    seen_recv_trailing_metadata_ready_ = false;
+    grpc_error_handle error = recv_trailing_metadata_ready_error_;
+    recv_trailing_metadata_ready_error_ = GRPC_ERROR_NONE;
+    GRPC_CALL_COMBINER_START(call_combiner_, &recv_trailing_metadata_ready_,
+                             error, "Continuing RecvTrailingMetadataReady");
+  }
+}
+
+}  // namespace
+
+const grpc_channel_filter kServerConfigSelectorFilter = {
+    CallData::StartTransportStreamOpBatch,
+    grpc_channel_next_op,
+    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,
+    "server_config_selector_filter",
+};
+
+}  // namespace grpc_core