grpc 1.45.0 → 1.47.0

data/src/core/lib/channel/promise_based_filter.h

@@ -21,20 +21,40 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/utility/utility.h"
+#include <stdint.h>
+#include <stdlib.h>
 
-#include <grpc/status.h>
+#include <atomic>
+#include <new>
+#include <type_traits>
+#include <utility>
+
+#include "absl/container/inlined_vector.h"
+#include "absl/meta/type_traits.h"
+
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/call_finalization.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/call_combiner.h"
+#include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/polling_entity.h"
+#include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/promise/context.h"
-#include "src/core/lib/promise/promise.h"
+#include "src/core/lib/promise/latch.h"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/transport/error_utils.h"
+#include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 
@@ -42,21 +62,28 @@ class ChannelFilter {
  public:
   class Args {
    public:
-    Args() : Args(nullptr) {}
-    explicit Args(grpc_channel_stack* channel_stack)
-        : channel_stack_(channel_stack) {}
+    Args() : Args(nullptr, nullptr) {}
+    explicit Args(grpc_channel_stack* channel_stack,
+                  grpc_channel_element* channel_element)
+        : channel_stack_(channel_stack), channel_element_(channel_element) {}
 
     grpc_channel_stack* channel_stack() const { return channel_stack_; }
+    grpc_channel_element* uninitialized_channel_element() {
+      return channel_element_;
+    }
 
    private:
     friend class ChannelFilter;
     grpc_channel_stack* channel_stack_;
+    grpc_channel_element* channel_element_;
   };
 
+  // Perform post-initialization step (if any).
+  virtual void PostInit() {}
+
   // Construct a promise for one call.
-  virtual ArenaPromise<TrailingMetadata> MakeCallPromise(
-      ClientInitialMetadata initial_metadata,
-      NextPromiseFactory next_promise_factory) = 0;
+  virtual ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs call_args, NextPromiseFactory next_promise_factory) = 0;
 
   // Start a legacy transport op
   // Return true if the op was handled, false if it should be passed to the
@@ -65,32 +92,50 @@ class ChannelFilter {
   // structures going forward.
   virtual bool StartTransportOp(grpc_transport_op*) { return false; }
 
- protected:
+  // Perform a legacy get info call
+  // Return true if the op was handled, false if it should be passed to the
+  // next filter.
+  // TODO(ctiller): design a new API for this
+  virtual bool GetChannelInfo(const grpc_channel_info*) { return false; }
+
   virtual ~ChannelFilter() = default;
 };
 
 // Designator for whether a filter is client side or server side.
-// Please don't use this outside calls to MakePromiseBasedFilter - it's intended
-// to be deleted once the promise conversion is complete.
+// Please don't use this outside calls to MakePromiseBasedFilter - it's
+// intended to be deleted once the promise conversion is complete.
 enum class FilterEndpoint {
   kClient,
   kServer,
 };
 
+// Flags for MakePromiseBasedFilter.
+static constexpr uint8_t kFilterExaminesServerInitialMetadata = 1;
+static constexpr uint8_t kFilterIsLast = 2;
+
 namespace promise_filter_detail {
 
+// Proxy channel filter for initialization failure, since we must leave a
+// valid filter in place.
+class InvalidChannelFilter : public ChannelFilter {
+ public:
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs, NextPromiseFactory) override {
+    abort();
+  }
+};
+
 // Call data shared between all implementations of promise-based filters.
 class BaseCallData : public Activity, private Wakeable {
  public:
-  BaseCallData(grpc_call_element* elem, const grpc_call_element_args* args)
-      : call_stack_(args->call_stack),
-        elem_(elem),
-        arena_(args->arena),
-        call_combiner_(args->call_combiner),
-        deadline_(args->deadline),
-        context_(args->context) {}
+  BaseCallData(grpc_call_element* elem, const grpc_call_element_args* args,
+               uint8_t flags);
+  ~BaseCallData() override;
 
-  void set_pollent(grpc_polling_entity* pollent) { pollent_ = pollent; }
+  void set_pollent(grpc_polling_entity* pollent) {
+    GPR_ASSERT(nullptr ==
+               pollent_.exchange(pollent, std::memory_order_release));
+  }
 
   // Activity implementation (partial).
   void Orphan() final;
@@ -112,11 +157,75 @@ class BaseCallData : public Activity, private Wakeable {
         : promise_detail::Context<Arena>(call_data->arena_),
           promise_detail::Context<grpc_call_context_element>(
               call_data->context_),
-          promise_detail::Context<grpc_polling_entity>(call_data->pollent_),
+          promise_detail::Context<grpc_polling_entity>(
+              call_data->pollent_.load(std::memory_order_acquire)),
           promise_detail::Context<CallFinalization>(&call_data->finalization_) {
     }
   };
 
+  class Flusher {
+   public:
+    explicit Flusher(BaseCallData* call);
+    // Calls closures, schedules batches, relinquishes call combiner.
+    ~Flusher();
+
+    void Resume(grpc_transport_stream_op_batch* batch) {
+      release_.push_back(batch);
+    }
+
+    void Cancel(grpc_transport_stream_op_batch* batch,
+                grpc_error_handle error) {
+      grpc_transport_stream_op_batch_queue_finish_with_failure(batch, error,
+                                                               &call_closures_);
+    }
+
+    void Complete(grpc_transport_stream_op_batch* batch) {
+      call_closures_.Add(batch->on_complete, GRPC_ERROR_NONE,
+                         "Flusher::Complete");
+    }
+
+    void AddClosure(grpc_closure* closure, grpc_error_handle error,
+                    const char* reason) {
+      call_closures_.Add(closure, error, reason);
+    }
+
+   private:
+    absl::InlinedVector<grpc_transport_stream_op_batch*, 1> release_;
+    CallCombinerClosureList call_closures_;
+    BaseCallData* const call_;
+  };
+
+  // Smart pointer like wrapper around a batch.
+  // Creation makes a ref count of one capture.
+  // Copying increments.
+  // Must be moved from or resumed or cancelled before destruction.
+  class CapturedBatch final {
+   public:
+    CapturedBatch();
+    explicit CapturedBatch(grpc_transport_stream_op_batch* batch);
+    ~CapturedBatch();
+    CapturedBatch(const CapturedBatch&);
+    CapturedBatch& operator=(const CapturedBatch&);
+    CapturedBatch(CapturedBatch&&) noexcept;
+    CapturedBatch& operator=(CapturedBatch&&) noexcept;
+
+    grpc_transport_stream_op_batch* operator->() { return batch_; }
+    bool is_captured() const { return batch_ != nullptr; }
+
+    // Resume processing this batch (releases one ref, passes it down the
+    // stack)
+    void ResumeWith(Flusher* releaser);
+    // Cancel this batch immediately (releases all refs)
+    void CancelWith(grpc_error_handle error, Flusher* releaser);
+    // Complete this batch (pass it up) assuming refs drop to zero
+    void CompleteWith(Flusher* releaser);
+
+    void Swap(CapturedBatch* other) { std::swap(batch_, other->batch_); }
+
+   private:
+    grpc_transport_stream_op_batch* batch_;
+  };
+
   static MetadataHandle<grpc_metadata_batch> WrapMetadata(
       grpc_metadata_batch* p) {
     return MetadataHandle<grpc_metadata_batch>(p);
@@ -127,10 +236,19 @@ class BaseCallData : public Activity, private Wakeable {
     return p.Unwrap();
   }
 
+  Arena* arena() { return arena_; }
   grpc_call_element* elem() const { return elem_; }
   CallCombiner* call_combiner() const { return call_combiner_; }
   Timestamp deadline() const { return deadline_; }
   grpc_call_stack* call_stack() const { return call_stack_; }
+  Latch<ServerMetadata*>* server_initial_metadata_latch() const {
+    return server_initial_metadata_latch_;
+  }
+
+  bool is_last() const {
+    return grpc_call_stack_element(call_stack_, call_stack_->count - 1) ==
+           elem_;
+  }
 
  private:
   // Wakeable implementation.
@@ -146,12 +264,14 @@ class BaseCallData : public Activity, private Wakeable {
   const Timestamp deadline_;
   CallFinalization finalization_;
   grpc_call_context_element* const context_;
-  grpc_polling_entity* pollent_ = nullptr;
+  std::atomic<grpc_polling_entity*> pollent_{nullptr};
+  Latch<ServerMetadata*>* server_initial_metadata_latch_ = nullptr;
 };
 
 class ClientCallData : public BaseCallData {
  public:
-  ClientCallData(grpc_call_element* elem, const grpc_call_element_args* args);
+  ClientCallData(grpc_call_element* elem, const grpc_call_element_args* args,
+                 uint8_t flags);
   ~ClientCallData() override;
 
   // Activity implementation.
@@ -177,7 +297,8 @@ class ClientCallData : public BaseCallData {
     // Start state: no op seen
     kInitial,
     // We saw the op, and since it was bundled with send initial metadata, we
-    // queued it until the send initial metadata can be sent to the next filter.
+    // queued it until the send initial metadata can be sent to the next
+    // filter.
     kQueued,
     // We've forwarded the op to the next filter.
     kForwarded,
@@ -192,42 +313,47 @@ class ClientCallData : public BaseCallData {
     kCancelled
   };
 
+  struct RecvInitialMetadata;
+  class PollContext;
+
   // Handle cancellation.
   void Cancel(grpc_error_handle error);
   // Begin running the promise - which will ultimately take some initial
   // metadata and return some trailing metadata.
-  void StartPromise();
-  // Interject our callback into the op batch for recv trailing metadata ready.
-  // Stash a pointer to the trailing metadata that will be filled in, so we can
-  // manipulate it later.
-  void HookRecvTrailingMetadata(grpc_transport_stream_op_batch* batch);
+  void StartPromise(Flusher* flusher);
+  // Interject our callback into the op batch for recv trailing metadata
+  // ready. Stash a pointer to the trailing metadata that will be filled in,
+  // so we can manipulate it later.
+  void HookRecvTrailingMetadata(CapturedBatch batch);
   // Construct a promise that will "call" the next filter.
   // Effectively:
   //   - put the modified initial metadata into the batch to be sent down.
   //   - return a wrapper around PollTrailingMetadata as the promise.
-  ArenaPromise<TrailingMetadata> MakeNextPromise(
-      ClientInitialMetadata initial_metadata);
+  ArenaPromise<ServerMetadataHandle> MakeNextPromise(CallArgs call_args);
   // Wrapper to make it look like we're calling the next filter as a promise.
   // First poll: send the send_initial_metadata op down the stack.
   // All polls: await receiving the trailing metadata, then return it to the
   // application.
-  Poll<TrailingMetadata> PollTrailingMetadata();
+  Poll<ServerMetadataHandle> PollTrailingMetadata();
   static void RecvTrailingMetadataReadyCallback(void* arg,
                                                 grpc_error_handle error);
   void RecvTrailingMetadataReady(grpc_error_handle error);
-  // Given an error, fill in TrailingMetadata to represent that error.
+  void RecvInitialMetadataReady(grpc_error_handle error);
+  // Given an error, fill in ServerMetadataHandle to represent that error.
   void SetStatusFromError(grpc_metadata_batch* metadata,
                           grpc_error_handle error);
   // Wakeup and poll the promise if appropriate.
-  void WakeInsideCombiner();
+  void WakeInsideCombiner(Flusher* flusher);
   void OnWakeup() override;
 
   // Contained promise
-  ArenaPromise<TrailingMetadata> promise_;
+  ArenaPromise<ServerMetadataHandle> promise_;
   // Queued batch containing at least a send_initial_metadata op.
-  grpc_transport_stream_op_batch* send_initial_metadata_batch_ = nullptr;
+  CapturedBatch send_initial_metadata_batch_;
   // Pointer to where trailing metadata will be stored.
   grpc_metadata_batch* recv_trailing_metadata_ = nullptr;
+  // State tracking recv initial metadata for filters that care about it.
+  RecvInitialMetadata* recv_initial_metadata_ = nullptr;
   // Closure to call when we're done with the trailing metadata.
   grpc_closure* original_recv_trailing_metadata_ready_ = nullptr;
   // Our closure pointing to RecvTrailingMetadataReadyCallback.
@@ -238,17 +364,14 @@ class ClientCallData : public BaseCallData {
   SendInitialState send_initial_state_ = SendInitialState::kInitial;
   // State of the recv_trailing_metadata op.
   RecvTrailingState recv_trailing_state_ = RecvTrailingState::kInitial;
-  // Whether we're currently polling the promise.
-  bool is_polling_ = false;
-  // Should we repoll after completing polling?
-  bool repoll_ = false;
-  // Whether we should forward send initial metadata after polling?
-  bool forward_send_initial_metadata_ = false;
+  // Polling related data. Non-null if we're actively polling
+  PollContext* poll_ctx_ = nullptr;
 };
 
 class ServerCallData : public BaseCallData {
  public:
-  ServerCallData(grpc_call_element* elem, const grpc_call_element_args* args);
+  ServerCallData(grpc_call_element* elem, const grpc_call_element_args* args,
+                 uint8_t flags);
   ~ServerCallData() override;
 
   // Activity implementation.
@@ -283,29 +406,33 @@ class ServerCallData : public BaseCallData {
     kCancelled
   };
 
+  class PollContext;
+  struct SendInitialMetadata;
+
   // Handle cancellation.
-  void Cancel(grpc_error_handle error);
+  void Cancel(grpc_error_handle error, Flusher* flusher);
   // Construct a promise that will "call" the next filter.
   // Effectively:
   //   - put the modified initial metadata into the batch being sent up.
   //   - return a wrapper around PollTrailingMetadata as the promise.
-  ArenaPromise<TrailingMetadata> MakeNextPromise(
-      ClientInitialMetadata initial_metadata);
+  ArenaPromise<ServerMetadataHandle> MakeNextPromise(CallArgs call_args);
   // Wrapper to make it look like we're calling the next filter as a promise.
   // All polls: await sending the trailing metadata, then foward it down the
   // stack.
-  Poll<TrailingMetadata> PollTrailingMetadata();
+  Poll<ServerMetadataHandle> PollTrailingMetadata();
   static void RecvInitialMetadataReadyCallback(void* arg,
                                                grpc_error_handle error);
   void RecvInitialMetadataReady(grpc_error_handle error);
   // Wakeup and poll the promise if appropriate.
-  void WakeInsideCombiner(absl::FunctionRef<void(grpc_error_handle)> cancel);
+  void WakeInsideCombiner(Flusher* flusher);
   void OnWakeup() override;
 
   // Contained promise
-  ArenaPromise<TrailingMetadata> promise_;
+  ArenaPromise<ServerMetadataHandle> promise_;
   // Pointer to where initial metadata will be stored.
   grpc_metadata_batch* recv_initial_metadata_ = nullptr;
+  // State for sending initial metadata.
+  SendInitialMetadata* send_initial_metadata_ = nullptr;
   // Closure to call when we're done with the trailing metadata.
   grpc_closure* original_recv_initial_metadata_ready_ = nullptr;
   // Our closure pointing to RecvInitialMetadataReadyCallback.
@@ -313,13 +440,13 @@ class ServerCallData : public BaseCallData {
   // Error received during cancellation.
   grpc_error_handle cancelled_error_ = GRPC_ERROR_NONE;
   // Trailing metadata batch
-  grpc_transport_stream_op_batch* send_trailing_metadata_batch_ = nullptr;
+  CapturedBatch send_trailing_metadata_batch_;
   // State of the send_initial_metadata op.
   RecvInitialState recv_initial_state_ = RecvInitialState::kInitial;
   // State of the recv_trailing_metadata op.
   SendTrailingState send_trailing_state_ = SendTrailingState::kInitial;
-  // Whether we're currently polling the promise.
-  bool is_polling_ = false;
+  // Current poll context (or nullptr if not polling).
+  PollContext* poll_ctx_ = nullptr;
   // Whether to forward the recv_initial_metadata op at the end of promise
   // wakeup.
   bool forward_recv_initial_metadata_callback_ = false;
@@ -351,11 +478,9 @@ class CallData<ChannelFilter, FilterEndpoint::kServer> : public ServerCallData {
 // class SomeChannelFilter : public ChannelFilter {
 //  public:
 //   static absl::StatusOr<SomeChannelFilter> Create(
-//       ChannelFilter::Args filter_args);
+//       ChannelArgs channel_args, ChannelFilter::Args filter_args);
 // };
-// TODO(ctiller): allow implementing get_channel_info, start_transport_op in
-// some way on ChannelFilter.
-template <typename F, FilterEndpoint kEndpoint>
+template <typename F, FilterEndpoint kEndpoint, uint8_t kFlags = 0>
 absl::enable_if_t<std::is_base_of<ChannelFilter, F>::value, grpc_channel_filter>
 MakePromiseBasedFilter(const char* name) {
   using CallData = promise_filter_detail::CallData<F, kEndpoint>;
@@ -366,15 +491,16 @@ MakePromiseBasedFilter(const char* name) {
         static_cast<CallData*>(elem->call_data)->StartBatch(batch);
       },
       // make_call_promise
-      [](grpc_channel_element* elem, ClientInitialMetadata initial_metadata,
+      [](grpc_channel_element* elem, CallArgs call_args,
          NextPromiseFactory next_promise_factory) {
-        return static_cast<F*>(elem->channel_data)
-            ->MakeCallPromise(std::move(initial_metadata),
+        return static_cast<ChannelFilter*>(elem->channel_data)
+            ->MakeCallPromise(std::move(call_args),
                               std::move(next_promise_factory));
       },
       // start_transport_op
       [](grpc_channel_element* elem, grpc_transport_op* op) {
-        if (!static_cast<F*>(elem->channel_data)->StartTransportOp(op)) {
+        if (!static_cast<ChannelFilter*>(elem->channel_data)
+                 ->StartTransportOp(op)) {
           grpc_channel_next_op(elem, op);
         }
       },
@@ -382,7 +508,7 @@ MakePromiseBasedFilter(const char* name) {
       sizeof(CallData),
       // init_call_elem
       [](grpc_call_element* elem, const grpc_call_element_args* args) {
-        new (elem->call_data) CallData(elem, args);
+        new (elem->call_data) CallData(elem, args, kFlags);
         return GRPC_ERROR_NONE;
       },
       // set_pollset_or_pollset_set
@@ -391,28 +517,49 @@ MakePromiseBasedFilter(const char* name) {
       },
       // destroy_call_elem
       [](grpc_call_element* elem, const grpc_call_final_info* final_info,
-         grpc_closure*) {
+         grpc_closure* then_schedule_closure) {
         auto* cd = static_cast<CallData*>(elem->call_data);
         cd->Finalize(final_info);
         cd->~CallData();
+        if ((kFlags & kFilterIsLast) != 0) {
+          ExecCtx::Run(DEBUG_LOCATION, then_schedule_closure, GRPC_ERROR_NONE);
+        } else {
+          GPR_ASSERT(then_schedule_closure == nullptr);
+        }
       },
       // sizeof_channel_data
       sizeof(F),
       // init_channel_elem
       [](grpc_channel_element* elem, grpc_channel_element_args* args) {
-        GPR_ASSERT(!args->is_last);
-        auto status = F::Create(args->channel_args,
-                                ChannelFilter::Args(args->channel_stack));
-        if (!status.ok()) return absl_status_to_grpc_error(status.status());
+        GPR_ASSERT(args->is_last == ((kFlags & kFilterIsLast) != 0));
+        auto status = F::Create(ChannelArgs::FromC(args->channel_args),
+                                ChannelFilter::Args(args->channel_stack, elem));
+        if (!status.ok()) {
+          static_assert(
+              sizeof(promise_filter_detail::InvalidChannelFilter) <= sizeof(F),
+              "InvalidChannelFilter must fit in F");
+          new (elem->channel_data)
+              promise_filter_detail::InvalidChannelFilter();
+          return absl_status_to_grpc_error(status.status());
+        }
         new (elem->channel_data) F(std::move(*status));
         return GRPC_ERROR_NONE;
       },
+      // post_init_channel_elem
+      [](grpc_channel_stack*, grpc_channel_element* elem) {
+        static_cast<ChannelFilter*>(elem->channel_data)->PostInit();
+      },
       // destroy_channel_elem
       [](grpc_channel_element* elem) {
-        static_cast<F*>(elem->channel_data)->~F();
+        static_cast<ChannelFilter*>(elem->channel_data)->~ChannelFilter();
       },
       // get_channel_info
-      grpc_channel_next_get_info,
+      [](grpc_channel_element* elem, const grpc_channel_info* info) {
+        if (!static_cast<ChannelFilter*>(elem->channel_data)
+                 ->GetChannelInfo(info)) {
+          grpc_channel_next_get_info(elem, info);
+        }
+      },
       // name
       name,
   };

data/src/core/lib/channel/status_util.cc

@@ -20,6 +20,8 @@
 
 #include "src/core/lib/channel/status_util.h"
 
+#include <string.h>
+
 #include "src/core/lib/gpr/useful.h"
 
 struct status_string_entry {

data/src/core/lib/channel/status_util.h

@@ -21,9 +21,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdbool.h>
-#include <string.h>
-
 #include <grpc/status.h>
 
 /// If \a status_str is a valid status string, sets \a status to the

data/src/core/lib/compression/compression_internal.cc

@@ -52,6 +52,48 @@ const char* CompressionAlgorithmAsString(grpc_compression_algorithm algorithm) {
   }
 }
 
+namespace {
+class CommaSeparatedLists {
+ public:
+  CommaSeparatedLists() : lists_{}, text_buffer_{} {
+    char* text_buffer = text_buffer_;
+    auto add_char = [&text_buffer, this](char c) {
+      if (text_buffer - text_buffer_ == kTextBufferSize) abort();
+      *text_buffer++ = c;
+    };
+    for (size_t list = 0; list < kNumLists; ++list) {
+      char* start = text_buffer;
+      for (size_t algorithm = 0; algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT;
+           ++algorithm) {
+        if ((list & (1 << algorithm)) == 0) continue;
+        if (start != text_buffer) {
+          add_char(',');
+          add_char(' ');
+        }
+        const char* name = CompressionAlgorithmAsString(
+            static_cast<grpc_compression_algorithm>(algorithm));
+        for (const char* p = name; *p != '\0'; ++p) {
+          add_char(*p);
+        }
+      }
+      lists_[list] = absl::string_view(start, text_buffer - start);
+    }
+    if (text_buffer - text_buffer_ != kTextBufferSize) abort();
+  }
+
+  absl::string_view operator[](size_t list) const { return lists_[list]; }
+
+ private:
+  static constexpr size_t kNumLists = 1 << GRPC_COMPRESS_ALGORITHMS_COUNT;
+  // Experimentally determined (tweak things until it runs).
+  static constexpr size_t kTextBufferSize = 86;
+  absl::string_view lists_[kNumLists];
+  char text_buffer_[kTextBufferSize];
+};
+
+const CommaSeparatedLists kCommaSeparatedLists;
+}  // namespace
+
 absl::optional<grpc_compression_algorithm> ParseCompressionAlgorithm(
     absl::string_view algorithm) {
   if (algorithm == "identity") {
@@ -165,19 +207,12 @@ void CompressionAlgorithmSet::Set(grpc_compression_algorithm algorithm) {
   }
 }
 
-std::string CompressionAlgorithmSet::ToString() const {
-  absl::InlinedVector<const char*, GRPC_COMPRESS_ALGORITHMS_COUNT> segments;
-  for (size_t i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
-    if (set_.is_set(i)) {
-      segments.push_back(CompressionAlgorithmAsString(
-          static_cast<grpc_compression_algorithm>(i)));
-    }
-  }
-  return absl::StrJoin(segments, ", ");
+absl::string_view CompressionAlgorithmSet::ToString() const {
+  return kCommaSeparatedLists[ToLegacyBitmask()];
 }
 
 Slice CompressionAlgorithmSet::ToSlice() const {
-  return Slice::FromCopiedString(ToString());
+  return Slice::FromStaticString(ToString());
 }
 
 CompressionAlgorithmSet CompressionAlgorithmSet::FromString(
@@ -194,13 +229,7 @@ CompressionAlgorithmSet CompressionAlgorithmSet::FromString(
 }
 
 uint32_t CompressionAlgorithmSet::ToLegacyBitmask() const {
-  uint32_t x = 0;
-  for (size_t i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
-    if (set_.is_set(i)) {
-      x |= (1u << i);
-    }
-  }
-  return x;
+  return set_.ToInt<uint32_t>();
 }
 
 absl::optional<grpc_compression_algorithm>

data/src/core/lib/compression/compression_internal.h

@@ -73,7 +73,7 @@ class CompressionAlgorithmSet {
   void Set(grpc_compression_algorithm algorithm);
 
   // Return a comma separated string of the algorithms in this set.
-  std::string ToString() const;
+  absl::string_view ToString() const;
   Slice ToSlice() const;
 
   // Return a bitmask of the algorithms in this set.

data/src/core/lib/config/core_configuration.cc

@@ -16,7 +16,10 @@
 
 #include "src/core/lib/config/core_configuration.h"
 
+#include <algorithm>
 #include <atomic>
+#include <utility>
+#include <vector>
 
 #include <grpc/support/log.h>
 

data/src/core/lib/config/core_configuration.h

@@ -18,13 +18,14 @@
 #include <grpc/support/port_platform.h>
 
 #include <atomic>
+#include <functional>
 
 #include "src/core/lib/channel/channel_args_preconditioning.h"
-#include "src/core/lib/channel/handshaker_registry.h"
 #include "src/core/lib/resolver/resolver_registry.h"
 #include "src/core/lib/security/credentials/channel_creds_registry.h"
 #include "src/core/lib/service_config/service_config_parser.h"
 #include "src/core/lib/surface/channel_init.h"
+#include "src/core/lib/transport/handshaker_registry.h"
 
 namespace grpc_core {