grpc 1.45.0 → 1.46.3

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

@@ -33,13 +33,14 @@ namespace grpc_core {
 
 class ClientAuthorityFilter final : public ChannelFilter {
  public:
-  static absl::StatusOr<ClientAuthorityFilter> Create(
-      const grpc_channel_args* args, ChannelFilter::Args);
+  static const grpc_channel_filter kFilter;
+
+  static absl::StatusOr<ClientAuthorityFilter> Create(ChannelArgs args,
+                                                      ChannelFilter::Args);
 
   // Construct a promise for one call.
-  ArenaPromise<TrailingMetadata> MakeCallPromise(
-      ClientInitialMetadata initial_metadata,
-      NextPromiseFactory next_promise_factory) override;
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
 
  private:
   explicit ClientAuthorityFilter(Slice default_authority)

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

@@ -66,6 +66,9 @@ void RegisterHttpFilters(CoreConfiguration::Builder* builder) {
           return true;
         });
   };
+  // TODO(ctiller): return this flag to true once the promise conversion is
+  // complete.
+  static constexpr bool kMinimalStackHasDecompression = false;
   optional(GRPC_CLIENT_SUBCHANNEL, false,
            GRPC_ARG_ENABLE_PER_MESSAGE_COMPRESSION,
            &grpc_message_compress_filter);
@@ -74,14 +77,14 @@ void RegisterHttpFilters(CoreConfiguration::Builder* builder) {
            &grpc_message_compress_filter);
   optional(GRPC_SERVER_CHANNEL, false, GRPC_ARG_ENABLE_PER_MESSAGE_COMPRESSION,
            &grpc_message_compress_filter);
-  optional(GRPC_CLIENT_SUBCHANNEL, true,
+  optional(GRPC_CLIENT_SUBCHANNEL, kMinimalStackHasDecompression,
            GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION, &MessageDecompressFilter);
-  optional(GRPC_CLIENT_DIRECT_CHANNEL, true,
+  optional(GRPC_CLIENT_DIRECT_CHANNEL, kMinimalStackHasDecompression,
            GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION, &MessageDecompressFilter);
-  optional(GRPC_SERVER_CHANNEL, true, GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION,
-           &MessageDecompressFilter);
-  required(GRPC_CLIENT_SUBCHANNEL, &grpc_http_client_filter);
-  required(GRPC_CLIENT_DIRECT_CHANNEL, &grpc_http_client_filter);
+  optional(GRPC_SERVER_CHANNEL, kMinimalStackHasDecompression,
+           GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION, &MessageDecompressFilter);
+  required(GRPC_CLIENT_SUBCHANNEL, &HttpClientFilter::kFilter);
+  required(GRPC_CLIENT_DIRECT_CHANNEL, &HttpClientFilter::kFilter);
   required(GRPC_SERVER_CHANNEL, &grpc_http_server_filter);
 }
 }  // namespace grpc_core

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

@@ -37,7 +37,6 @@ static void hs_recv_initial_metadata_ready(void* user_data,
                                            grpc_error_handle err);
 static void hs_recv_trailing_metadata_ready(void* user_data,
                                             grpc_error_handle err);
-static void hs_recv_message_ready(void* user_data, grpc_error_handle err);
 
 namespace {
 
@@ -47,27 +46,15 @@ struct call_data {
     GRPC_CLOSURE_INIT(&recv_initial_metadata_ready,
                       hs_recv_initial_metadata_ready, elem,
                       grpc_schedule_on_exec_ctx);
-    GRPC_CLOSURE_INIT(&recv_message_ready, hs_recv_message_ready, elem,
-                      grpc_schedule_on_exec_ctx);
     GRPC_CLOSURE_INIT(&recv_trailing_metadata_ready,
                       hs_recv_trailing_metadata_ready, elem,
                       grpc_schedule_on_exec_ctx);
   }
 
-  ~call_data() {
-    GRPC_ERROR_UNREF(recv_initial_metadata_ready_error);
-    if (have_read_stream) {
-      read_stream->Orphan();
-    }
-  }
+  ~call_data() { GRPC_ERROR_UNREF(recv_initial_metadata_ready_error); }
 
   grpc_core::CallCombiner* call_combiner;
 
-  // If we see the recv_message contents in the GET query string, we
-  // store it here.
-  grpc_core::ManualConstructor<grpc_core::SliceBufferByteStream> read_stream;
-  bool have_read_stream = false;
-
   // State for intercepting recv_initial_metadata.
   grpc_closure recv_initial_metadata_ready;
   grpc_error_handle recv_initial_metadata_ready_error = GRPC_ERROR_NONE;
@@ -76,12 +63,6 @@ struct call_data {
   uint32_t* recv_initial_metadata_flags;
   bool seen_recv_initial_metadata_ready = false;
 
-  // State for intercepting recv_message.
-  grpc_closure* original_recv_message_ready;
-  grpc_closure recv_message_ready;
-  grpc_core::OrphanablePtr<grpc_core::ByteStream>* recv_message;
-  bool seen_recv_message_ready = false;
-
   // State for intercepting recv_trailing_metadata
   grpc_closure recv_trailing_metadata_ready;
   grpc_closure* original_recv_trailing_metadata_ready;
@@ -115,7 +96,6 @@ static void hs_add_error(const char* error_name, grpc_error_handle* cumulative,
 
 static grpc_error_handle hs_filter_incoming_metadata(grpc_call_element* elem,
                                                      grpc_metadata_batch* b) {
-  call_data* calld = static_cast<call_data*>(elem->call_data);
   grpc_error_handle error = GRPC_ERROR_NONE;
   static const char* error_name = "Failed processing incoming headers";
 
@@ -123,23 +103,9 @@ static grpc_error_handle hs_filter_incoming_metadata(grpc_call_element* elem,
   if (method.has_value()) {
     switch (*method) {
       case grpc_core::HttpMethodMetadata::kPost:
-        *calld->recv_initial_metadata_flags &=
-            ~(GRPC_INITIAL_METADATA_CACHEABLE_REQUEST |
-              GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST);
-        break;
-      case grpc_core::HttpMethodMetadata::kPut:
-        *calld->recv_initial_metadata_flags &=
-            ~GRPC_INITIAL_METADATA_CACHEABLE_REQUEST;
-        *calld->recv_initial_metadata_flags |=
-            GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST;
-        break;
-      case grpc_core::HttpMethodMetadata::kGet:
-        *calld->recv_initial_metadata_flags |=
-            GRPC_INITIAL_METADATA_CACHEABLE_REQUEST;
-        *calld->recv_initial_metadata_flags &=
-            ~GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST;
         break;
       case grpc_core::HttpMethodMetadata::kInvalid:
+      case grpc_core::HttpMethodMetadata::kGet:
         hs_add_error(error_name, &error,
                      GRPC_ERROR_CREATE_FROM_STATIC_STRING("Bad method header"));
         break;
@@ -185,38 +151,6 @@ static grpc_error_handle hs_filter_incoming_metadata(grpc_call_element* elem,
                  grpc_error_set_str(
                      GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing header"),
                      GRPC_ERROR_STR_KEY, ":path"));
-  } else if (*calld->recv_initial_metadata_flags &
-             GRPC_INITIAL_METADATA_CACHEABLE_REQUEST) {
-    /* We have a cacheable request made with GET verb. The path contains the
-     * query parameter which is base64 encoded request payload. */
-    static const char kQuerySeparator = '?';
-    /* offset of the character '?' */
-    auto it =
-        std::find(path_slice->begin(), path_slice->end(), kQuerySeparator);
-    if (it != path_slice->end()) {
-      const auto query_start = it - path_slice->begin() + 1;
-      auto query_slice = path_slice->RefSubSlice(
-          query_start, path_slice->size() - query_start);
-
-      /* substitute path metadata with just the path (not query) */
-      auto path_without_query = path_slice->TakeSubSlice(0, query_start - 1);
-      *path_slice = std::move(path_without_query);
-
-      /* decode payload from query and add to the slice buffer to be returned */
-      const int k_url_safe = 1;
-      grpc_slice_buffer read_slice_buffer;
-      grpc_slice_buffer_init(&read_slice_buffer);
-      grpc_slice_buffer_add(
-          &read_slice_buffer,
-          grpc_base64_decode_with_len(
-              reinterpret_cast<const char*>(query_slice.begin()),
-              query_slice.size(), k_url_safe));
-      calld->read_stream.Init(&read_slice_buffer, 0);
-      grpc_slice_buffer_destroy_internal(&read_slice_buffer);
-      calld->have_read_stream = true;
-    } else {
-      gpr_log(GPR_ERROR, "GET request without QUERY");
-    }
   }
 
   if (b->get_pointer(grpc_core::HttpAuthorityMetadata()) == nullptr) {
@@ -249,22 +183,6 @@ static void hs_recv_initial_metadata_ready(void* user_data,
   if (err == GRPC_ERROR_NONE) {
     err = hs_filter_incoming_metadata(elem, calld->recv_initial_metadata);
     calld->recv_initial_metadata_ready_error = GRPC_ERROR_REF(err);
-    if (calld->seen_recv_message_ready) {
-      // We've already seen the recv_message callback, but we previously
-      // deferred it, so we need to return it here.
-      // Replace the recv_message byte stream if needed.
-      if (calld->have_read_stream) {
-        calld->recv_message->reset(calld->read_stream.get());
-        calld->have_read_stream = false;
-      }
-      // Re-enter call combiner for original_recv_message_ready, since the
-      // surface code will release the call combiner for each callback it
-      // receives.
-      GRPC_CALL_COMBINER_START(
-          calld->call_combiner, calld->original_recv_message_ready,
-          GRPC_ERROR_REF(err),
-          "resuming recv_message_ready from recv_initial_metadata_ready");
-    }
   } else {
     (void)GRPC_ERROR_REF(err);
   }
@@ -279,31 +197,6 @@ static void hs_recv_initial_metadata_ready(void* user_data,
                           calld->original_recv_initial_metadata_ready, err);
 }
 
-static void hs_recv_message_ready(void* user_data, grpc_error_handle err) {
-  grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  calld->seen_recv_message_ready = true;
-  if (calld->seen_recv_initial_metadata_ready) {
-    // We've already seen the recv_initial_metadata callback, so
-    // replace the recv_message byte stream if needed and invoke the
-    // original recv_message callback immediately.
-    if (calld->have_read_stream) {
-      calld->recv_message->reset(calld->read_stream.get());
-      calld->have_read_stream = false;
-    }
-    grpc_core::Closure::Run(DEBUG_LOCATION, calld->original_recv_message_ready,
-                            GRPC_ERROR_REF(err));
-  } else {
-    // We have not yet seen the recv_initial_metadata callback, so we
-    // need to wait to see if this is a GET request.
-    // Note that we release the call combiner here, so that other
-    // callbacks can run.
-    GRPC_CALL_COMBINER_STOP(
-        calld->call_combiner,
-        "pausing recv_message_ready until recv_initial_metadata_ready");
-  }
-}
-
 static void hs_recv_trailing_metadata_ready(void* user_data,
                                             grpc_error_handle err) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
@@ -355,13 +248,6 @@ static grpc_error_handle hs_mutate_op(grpc_call_element* elem,
         &calld->recv_initial_metadata_ready;
   }
 
-  if (op->recv_message) {
-    calld->recv_message = op->payload->recv_message.recv_message;
-    calld->original_recv_message_ready =
-        op->payload->recv_message.recv_message_ready;
-    op->payload->recv_message.recv_message_ready = &calld->recv_message_ready;
-  }
-
   if (op->recv_trailing_metadata) {
     calld->original_recv_trailing_metadata_ready =
         op->payload->recv_trailing_metadata.recv_trailing_metadata_ready;

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

@@ -54,14 +54,8 @@ grpc_arg ServerConfigSelectorProvider::MakeChannelArg() const {
       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;
+absl::string_view ServerConfigSelectorProvider::ChannelArgName() {
+  return kServerConfigSelectorProviderChannelArgName;
 }
 
 }  // namespace grpc_core

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

@@ -61,9 +61,9 @@ class ServerConfigSelectorProvider
       std::unique_ptr<ServerConfigSelectorWatcher> watcher) = 0;
   virtual void CancelWatch() = 0;
 
+  static absl::string_view ChannelArgName();
+
   grpc_arg MakeChannelArg() const;
-  static RefCountedPtr<ServerConfigSelectorProvider> GetFromChannelArgs(
-      const grpc_channel_args& args);
 };
 
 }  // namespace grpc_core

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

@@ -1,5 +1,3 @@
-//
-//
 // Copyright 2021 gRPC authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,14 +11,16 @@
 // 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/lib/channel/promise_based_filter.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/promise/promise.h"
+#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/service_config/service_config_call_data.h"
 #include "src/core/lib/transport/error_utils.h"
 
@@ -28,244 +28,116 @@ namespace grpc_core {
 
 namespace {
 
-class ChannelData {
+class ServerConfigSelectorFilter final : public ChannelFilter {
  public:
-  static grpc_error_handle Init(grpc_channel_element* elem,
-                                grpc_channel_element_args* args);
-  static void Destroy(grpc_channel_element* elem);
+  ~ServerConfigSelectorFilter() override;
+
+  ServerConfigSelectorFilter(const ServerConfigSelectorFilter&) = delete;
+  ServerConfigSelectorFilter& operator=(const ServerConfigSelectorFilter&) =
+      delete;
+  ServerConfigSelectorFilter(ServerConfigSelectorFilter&&) = default;
+  ServerConfigSelectorFilter& operator=(ServerConfigSelectorFilter&&) = default;
+
+  static absl::StatusOr<ServerConfigSelectorFilter> Create(ChannelArgs args,
+                                                           ChannelFilter::Args);
+
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
 
   absl::StatusOr<RefCountedPtr<ServerConfigSelector>> config_selector() {
-    MutexLock lock(&mu_);
-    return config_selector_.value();
+    MutexLock lock(&state_->mu);
+    return state_->config_selector.value();
   }
 
  private:
+  struct State {
+    Mutex mu;
+    absl::optional<absl::StatusOr<RefCountedPtr<ServerConfigSelector>>>
+        config_selector ABSL_GUARDED_BY(mu);
+  };
   class ServerConfigSelectorWatcher
       : public ServerConfigSelectorProvider::ServerConfigSelectorWatcher {
    public:
-    explicit ServerConfigSelectorWatcher(ChannelData* chand) : chand_(chand) {}
+    explicit ServerConfigSelectorWatcher(std::shared_ptr<State> state)
+        : state_(state) {}
     void OnServerConfigSelectorUpdate(
         absl::StatusOr<RefCountedPtr<ServerConfigSelector>> update) override {
-      MutexLock lock(&chand_->mu_);
-      chand_->config_selector_ = std::move(update);
+      MutexLock lock(&state_->mu);
+      state_->config_selector = std::move(update);
     }
 
    private:
-    ChannelData* chand_;
+    std::shared_ptr<State> state_;
   };
 
-  explicit ChannelData(RefCountedPtr<ServerConfigSelectorProvider>
-                           server_config_selector_provider);
-  ~ChannelData();
+  explicit ServerConfigSelectorFilter(
+      RefCountedPtr<ServerConfigSelectorProvider>
+          server_config_selector_provider);
 
   RefCountedPtr<ServerConfigSelectorProvider> server_config_selector_provider_;
-  Mutex mu_;
-  absl::optional<absl::StatusOr<RefCountedPtr<ServerConfigSelector>>>
-      config_selector_ ABSL_GUARDED_BY(mu_);
+  std::shared_ptr<State> state_;
 };
 
-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);
+absl::StatusOr<ServerConfigSelectorFilter> ServerConfigSelectorFilter::Create(
+    ChannelArgs args, ChannelFilter::Args) {
+  ServerConfigSelectorProvider* server_config_selector_provider =
+      args.GetObject<ServerConfigSelectorProvider>();
   if (server_config_selector_provider == nullptr) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "No ServerConfigSelectorProvider object found");
+    return absl::UnknownError("No ServerConfigSelectorProvider object found");
   }
-  new (elem->channel_data)
-      ChannelData(std::move(server_config_selector_provider));
-  return GRPC_ERROR_NONE;
+  return ServerConfigSelectorFilter(server_config_selector_provider->Ref());
 }
 
-void ChannelData::Destroy(grpc_channel_element* elem) {
-  auto* chand = static_cast<ChannelData*>(elem->channel_data);
-  chand->~ChannelData();
-}
-
-ChannelData::ChannelData(
+ServerConfigSelectorFilter::ServerConfigSelectorFilter(
     RefCountedPtr<ServerConfigSelectorProvider> server_config_selector_provider)
     : server_config_selector_provider_(
-          std::move(server_config_selector_provider)) {
+          std::move(server_config_selector_provider)),
+      state_(std::make_shared<State>()) {
   GPR_ASSERT(server_config_selector_provider_ != nullptr);
   auto server_config_selector_watcher =
-      absl::make_unique<ServerConfigSelectorWatcher>(this);
+      absl::make_unique<ServerConfigSelectorWatcher>(state_);
   auto config_selector = server_config_selector_provider_->Watch(
       std::move(server_config_selector_watcher));
-  MutexLock lock(&mu_);
+  MutexLock lock(&state_->mu);
   // It's possible for the watcher to have already updated config_selector_
-  if (!config_selector_.has_value()) {
-    config_selector_ = std::move(config_selector);
+  if (!state_->config_selector.has_value()) {
+    state_->config_selector = std::move(config_selector);
   }
 }
 
-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_;
-    }
+ServerConfigSelectorFilter::~ServerConfigSelectorFilter() {
+  if (server_config_selector_provider_ != nullptr) {
+    server_config_selector_provider_->CancelWatch();
   }
-  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");
+ArenaPromise<ServerMetadataHandle> ServerConfigSelectorFilter::MakeCallPromise(
+    CallArgs call_args, NextPromiseFactory next_promise_factory) {
+  auto sel = config_selector();
+  if (!sel.ok()) return Immediate(ServerMetadataHandle(sel.status()));
+  auto call_config =
+      sel.value()->GetCallConfig(call_args.client_initial_metadata.get());
+  if (call_config.error != GRPC_ERROR_NONE) {
+    auto r = Immediate(ServerMetadataHandle(
+        absl::UnavailableError(grpc_error_std_string(call_config.error))));
+    GRPC_ERROR_UNREF(call_config.error);
+    return std::move(r);
   }
+  auto& ctx = GetContext<
+      grpc_call_context_element>()[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA];
+  ctx.value = GetContext<Arena>()->New<ServiceConfigCallData>(
+      std::move(call_config.service_config), call_config.method_configs,
+      ServiceConfigCallData::CallAttributes{});
+  ctx.destroy = [](void* p) {
+    static_cast<ServiceConfigCallData*>(p)->~ServiceConfigCallData();
+  };
+  return next_promise_factory(std::move(call_args));
 }
 
 }  // namespace
 
-const grpc_channel_filter kServerConfigSelectorFilter = {
-    CallData::StartTransportStreamOpBatch,
-    nullptr,
-    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",
-};
+const grpc_channel_filter kServerConfigSelectorFilter =
+    MakePromiseBasedFilter<ServerConfigSelectorFilter, FilterEndpoint::kServer>(
+        "server_config_selector_filter");
 
 }  // namespace grpc_core

data/src/core/ext/transport/chttp2/client/chttp2_connector.cc

@@ -41,6 +41,7 @@
 #include "src/core/lib/resolver/resolver_registry.h"
 #include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/security/credentials/credentials.h"
+#include "src/core/lib/security/credentials/insecure/insecure_credentials.h"
 #include "src/core/lib/security/security_connector/security_connector.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/api_trace.h"
@@ -438,7 +439,7 @@ grpc_channel* grpc_channel_create_from_fd(const char* target, int fd,
       (target, fd, creds, args));
   // For now, we only support insecure channel credentials.
   if (creds == nullptr ||
-      strcmp(creds->type(), GRPC_CREDENTIALS_TYPE_INSECURE) != 0) {
+      creds->type() != grpc_core::InsecureServerCredentials::Type()) {
     return grpc_lame_client_channel_create(
         target, GRPC_STATUS_INTERNAL,
         "Failed to create client channel due to invalid creds");

data/src/core/ext/transport/chttp2/server/chttp2_server.cc

@@ -55,6 +55,7 @@
 #include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/security/context/security_context.h"
 #include "src/core/lib/security/credentials/credentials.h"
+#include "src/core/lib/security/credentials/insecure/insecure_credentials.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/server.h"
@@ -940,9 +941,9 @@ grpc_error_handle Chttp2ServerAddPort(Server* server, const char* addr,
       }
     }
     if (error_list.size() == resolved_or->size()) {
-      std::string msg =
-          absl::StrFormat("No address added out of total %" PRIuPTR " resolved",
-                          resolved_or->size());
+      std::string msg = absl::StrFormat(
+          "No address added out of total %" PRIuPTR " resolved for '%s'",
+          resolved_or->size(), addr);
       return GRPC_ERROR_CREATE_REFERENCING_FROM_COPIED_STRING(
           msg.c_str(), error_list.data(), error_list.size());
     } else if (!error_list.empty()) {
@@ -1059,7 +1060,7 @@ void grpc_server_add_channel_from_fd(grpc_server* server, int fd,
                                      grpc_server_credentials* creds) {
   // For now, we only support insecure server credentials
   if (creds == nullptr ||
-      strcmp(creds->type(), GRPC_CREDENTIALS_TYPE_INSECURE) != 0) {
+      creds->type() != grpc_core::InsecureServerCredentials::Type()) {
     gpr_log(GPR_ERROR, "Failed to create channel due to invalid creds");
     return;
   }