grpc 1.40.0.pre1 → 1.41.1

data/src/core/lib/address_utils/parse_address.cc

@@ -87,10 +87,8 @@ grpc_error_handle UnixSockaddrPopulate(absl::string_view path,
       reinterpret_cast<struct sockaddr_un*>(resolved_addr->addr);
   const size_t maxlen = sizeof(un->sun_path) - 1;
   if (path.size() > maxlen) {
-    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        absl::StrCat("Path name should not have more than ", maxlen,
-                     " characters")
-            .c_str());
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+        "Path name should not have more than ", maxlen, " characters"));
   }
   un->sun_family = AF_UNIX;
   path.copy(un->sun_path, path.size());
@@ -105,10 +103,8 @@ grpc_error_handle UnixAbstractSockaddrPopulate(
       reinterpret_cast<struct sockaddr_un*>(resolved_addr->addr);
   const size_t maxlen = sizeof(un->sun_path) - 1;
   if (path.size() > maxlen) {
-    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        absl::StrCat("Path name should not have more than ", maxlen,
-                     " characters")
-            .c_str());
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+        "Path name should not have more than ", maxlen, " characters"));
   }
   un->sun_family = AF_UNIX;
   un->sun_path[0] = '\0';

data/src/core/lib/address_utils/sockaddr_utils.cc

@@ -212,8 +212,8 @@ grpc_error_handle grpc_string_to_sockaddr(grpc_resolved_address* out,
     addr4->sin_family = GRPC_AF_INET;
     out->len = sizeof(grpc_sockaddr_in);
   } else {
-    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        absl::StrCat("Failed to parse address:", addr).c_str());
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+        absl::StrCat("Failed to parse address:", addr));
   }
   grpc_sockaddr_set_port(out, port);
   return GRPC_ERROR_NONE;

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

@@ -18,6 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/channel/channel_args.h"
+
 #include <limits.h>
 #include <string.h>
 
@@ -33,7 +35,6 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
 

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

@@ -18,14 +18,16 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/gpr/alloc.h"
 
 #include <stdlib.h>
 #include <string.h>
 
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/gpr/alloc.h"
+
 grpc_core::TraceFlag grpc_trace_channel(false, "channel");
 
 /* Memory layouts.

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

@@ -41,6 +41,7 @@ struct grpc_channel_stack_builder {
   grpc_channel_args* args;
   grpc_transport* transport;
   grpc_resource_user* resource_user;
+  size_t preallocated_bytes;
   char* target;
   const char* name;
 };
@@ -174,17 +175,6 @@ grpc_transport* grpc_channel_stack_builder_get_transport(
   return builder->transport;
 }
 
-void grpc_channel_stack_builder_set_resource_user(
-    grpc_channel_stack_builder* builder, grpc_resource_user* resource_user) {
-  GPR_ASSERT(builder->resource_user == nullptr);
-  builder->resource_user = resource_user;
-}
-
-grpc_resource_user* grpc_channel_stack_builder_get_resource_user(
-    grpc_channel_stack_builder* builder) {
-  return builder->resource_user;
-}
-
 bool grpc_channel_stack_builder_append_filter(
     grpc_channel_stack_builder* builder, const grpc_channel_filter* filter,
     grpc_post_filter_create_init_func post_init_func, void* user_data) {

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

@@ -54,14 +54,6 @@ void grpc_channel_stack_builder_set_transport(
 grpc_transport* grpc_channel_stack_builder_get_transport(
     grpc_channel_stack_builder* builder);
 
-/// Attach \a resource_user to the builder (does not take ownership)
-void grpc_channel_stack_builder_set_resource_user(
-    grpc_channel_stack_builder* builder, grpc_resource_user* resource_user);
-
-/// Fetch attached resource user
-grpc_resource_user* grpc_channel_stack_builder_get_resource_user(
-    grpc_channel_stack_builder* builder);
-
 /// Set channel arguments: copies args
 void grpc_channel_stack_builder_set_channel_arguments(
     grpc_channel_stack_builder* builder, const grpc_channel_args* args);

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

@@ -20,13 +20,14 @@
 
 #include "src/core/lib/channel/channel_trace.h"
 
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
 
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/gpr/string.h"

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

@@ -22,6 +22,7 @@
 #include <grpc/impl/codegen/port_platform.h>
 
 #include <grpc/grpc.h>
+
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/error.h"

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

@@ -24,6 +24,8 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <atomic>
+
 #include "absl/strings/escaping.h"
 #include "absl/strings/strip.h"
 
@@ -37,7 +39,6 @@
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/error.h"
@@ -86,34 +87,34 @@ CallCountingHelper::CallCountingHelper() {
 void CallCountingHelper::RecordCallStarted() {
   AtomicCounterData& data =
       per_cpu_counter_data_storage_[ExecCtx::Get()->starting_cpu()];
-  data.calls_started.FetchAdd(1, MemoryOrder::RELAXED);
-  data.last_call_started_cycle.Store(gpr_get_cycle_counter(),
-                                     MemoryOrder::RELAXED);
+  data.calls_started.fetch_add(1, std::memory_order_relaxed);
+  data.last_call_started_cycle.store(gpr_get_cycle_counter(),
+                                     std::memory_order_relaxed);
 }
 
 void CallCountingHelper::RecordCallFailed() {
   per_cpu_counter_data_storage_[ExecCtx::Get()->starting_cpu()]
-      .calls_failed.FetchAdd(1, MemoryOrder::RELAXED);
+      .calls_failed.fetch_add(1, std::memory_order_relaxed);
 }
 
 void CallCountingHelper::RecordCallSucceeded() {
   per_cpu_counter_data_storage_[ExecCtx::Get()->starting_cpu()]
-      .calls_succeeded.FetchAdd(1, MemoryOrder::RELAXED);
+      .calls_succeeded.fetch_add(1, std::memory_order_relaxed);
 }
 
 void CallCountingHelper::CollectData(CounterData* out) {
   for (size_t core = 0; core < num_cores_; ++core) {
     AtomicCounterData& data = per_cpu_counter_data_storage_[core];
 
-    out->calls_started += data.calls_started.Load(MemoryOrder::RELAXED);
+    out->calls_started += data.calls_started.load(std::memory_order_relaxed);
     out->calls_succeeded +=
-        per_cpu_counter_data_storage_[core].calls_succeeded.Load(
-            MemoryOrder::RELAXED);
-    out->calls_failed += per_cpu_counter_data_storage_[core].calls_failed.Load(
-        MemoryOrder::RELAXED);
+        per_cpu_counter_data_storage_[core].calls_succeeded.load(
+            std::memory_order_relaxed);
+    out->calls_failed += per_cpu_counter_data_storage_[core].calls_failed.load(
+        std::memory_order_relaxed);
     const gpr_cycle_counter last_call =
-        per_cpu_counter_data_storage_[core].last_call_started_cycle.Load(
-            MemoryOrder::RELAXED);
+        per_cpu_counter_data_storage_[core].last_call_started_cycle.load(
+            std::memory_order_relaxed);
     if (last_call > out->last_call_started_cycle) {
       out->last_call_started_cycle = last_call;
     }
@@ -173,7 +174,7 @@ Json ChannelNode::RenderJson() {
   };
   // Connectivity state.
   // If low-order bit is on, then the field is set.
-  int state_field = connectivity_state_.Load(MemoryOrder::RELAXED);
+  int state_field = connectivity_state_.load(std::memory_order_relaxed);
   if ((state_field & 1) != 0) {
     grpc_connectivity_state state =
         static_cast<grpc_connectivity_state>(state_field >> 1);
@@ -227,7 +228,7 @@ void ChannelNode::PopulateChildRefs(Json::Object* json) {
 void ChannelNode::SetConnectivityState(grpc_connectivity_state state) {
   // Store with low-order bit set to indicate that the field is set.
   int state_field = (state << 1) + 1;
-  connectivity_state_.Store(state_field, MemoryOrder::RELAXED);
+  connectivity_state_.store(state_field, std::memory_order_relaxed);
 }
 
 void ChannelNode::AddChildChannel(intptr_t child_uuid) {
@@ -474,37 +475,38 @@ SocketNode::SocketNode(std::string local, std::string remote, std::string name,
       security_(std::move(security)) {}
 
 void SocketNode::RecordStreamStartedFromLocal() {
-  streams_started_.FetchAdd(1, MemoryOrder::RELAXED);
-  last_local_stream_created_cycle_.Store(gpr_get_cycle_counter(),
-                                         MemoryOrder::RELAXED);
+  streams_started_.fetch_add(1, std::memory_order_relaxed);
+  last_local_stream_created_cycle_.store(gpr_get_cycle_counter(),
+                                         std::memory_order_relaxed);
 }
 
 void SocketNode::RecordStreamStartedFromRemote() {
-  streams_started_.FetchAdd(1, MemoryOrder::RELAXED);
-  last_remote_stream_created_cycle_.Store(gpr_get_cycle_counter(),
-                                          MemoryOrder::RELAXED);
+  streams_started_.fetch_add(1, std::memory_order_relaxed);
+  last_remote_stream_created_cycle_.store(gpr_get_cycle_counter(),
+                                          std::memory_order_relaxed);
 }
 
 void SocketNode::RecordMessagesSent(uint32_t num_sent) {
-  messages_sent_.FetchAdd(num_sent, MemoryOrder::RELAXED);
-  last_message_sent_cycle_.Store(gpr_get_cycle_counter(), MemoryOrder::RELAXED);
+  messages_sent_.fetch_add(num_sent, std::memory_order_relaxed);
+  last_message_sent_cycle_.store(gpr_get_cycle_counter(),
+                                 std::memory_order_relaxed);
 }
 
 void SocketNode::RecordMessageReceived() {
-  messages_received_.FetchAdd(1, MemoryOrder::RELAXED);
-  last_message_received_cycle_.Store(gpr_get_cycle_counter(),
-                                     MemoryOrder::RELAXED);
+  messages_received_.fetch_add(1, std::memory_order_relaxed);
+  last_message_received_cycle_.store(gpr_get_cycle_counter(),
+                                     std::memory_order_relaxed);
 }
 
 Json SocketNode::RenderJson() {
   // Create and fill the data child.
   Json::Object data;
   gpr_timespec ts;
-  int64_t streams_started = streams_started_.Load(MemoryOrder::RELAXED);
+  int64_t streams_started = streams_started_.load(std::memory_order_relaxed);
   if (streams_started != 0) {
     data["streamsStarted"] = std::to_string(streams_started);
     gpr_cycle_counter last_local_stream_created_cycle =
-        last_local_stream_created_cycle_.Load(MemoryOrder::RELAXED);
+        last_local_stream_created_cycle_.load(std::memory_order_relaxed);
     if (last_local_stream_created_cycle != 0) {
       ts = gpr_convert_clock_type(
           gpr_cycle_counter_to_time(last_local_stream_created_cycle),
@@ -512,7 +514,7 @@ Json SocketNode::RenderJson() {
       data["lastLocalStreamCreatedTimestamp"] = gpr_format_timespec(ts);
     }
     gpr_cycle_counter last_remote_stream_created_cycle =
-        last_remote_stream_created_cycle_.Load(MemoryOrder::RELAXED);
+        last_remote_stream_created_cycle_.load(std::memory_order_relaxed);
     if (last_remote_stream_created_cycle != 0) {
       ts = gpr_convert_clock_type(
           gpr_cycle_counter_to_time(last_remote_stream_created_cycle),
@@ -520,33 +522,35 @@ Json SocketNode::RenderJson() {
       data["lastRemoteStreamCreatedTimestamp"] = gpr_format_timespec(ts);
     }
   }
-  int64_t streams_succeeded = streams_succeeded_.Load(MemoryOrder::RELAXED);
+  int64_t streams_succeeded =
+      streams_succeeded_.load(std::memory_order_relaxed);
   if (streams_succeeded != 0) {
     data["streamsSucceeded"] = std::to_string(streams_succeeded);
   }
-  int64_t streams_failed = streams_failed_.Load(MemoryOrder::RELAXED);
+  int64_t streams_failed = streams_failed_.load(std::memory_order_relaxed);
   if (streams_failed != 0) {
     data["streamsFailed"] = std::to_string(streams_failed);
   }
-  int64_t messages_sent = messages_sent_.Load(MemoryOrder::RELAXED);
+  int64_t messages_sent = messages_sent_.load(std::memory_order_relaxed);
   if (messages_sent != 0) {
     data["messagesSent"] = std::to_string(messages_sent);
     ts = gpr_convert_clock_type(
         gpr_cycle_counter_to_time(
-            last_message_sent_cycle_.Load(MemoryOrder::RELAXED)),
+            last_message_sent_cycle_.load(std::memory_order_relaxed)),
         GPR_CLOCK_REALTIME);
     data["lastMessageSentTimestamp"] = gpr_format_timespec(ts);
   }
-  int64_t messages_received = messages_received_.Load(MemoryOrder::RELAXED);
+  int64_t messages_received =
+      messages_received_.load(std::memory_order_relaxed);
   if (messages_received != 0) {
     data["messagesReceived"] = std::to_string(messages_received);
     ts = gpr_convert_clock_type(
         gpr_cycle_counter_to_time(
-            last_message_received_cycle_.Load(MemoryOrder::RELAXED)),
+            last_message_received_cycle_.load(std::memory_order_relaxed)),
         GPR_CLOCK_REALTIME);
     data["lastMessageReceivedTimestamp"] = gpr_format_timespec(ts);
   }
-  int64_t keepalives_sent = keepalives_sent_.Load(MemoryOrder::RELAXED);
+  int64_t keepalives_sent = keepalives_sent_.load(std::memory_order_relaxed);
   if (keepalives_sent != 0) {
     data["keepAlivesSent"] = std::to_string(keepalives_sent);
   }

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

@@ -21,17 +21,17 @@
 
 #include <grpc/impl/codegen/port_platform.h>
 
-#include <grpc/grpc.h>
-
+#include <atomic>
 #include <set>
 #include <string>
 
 #include "absl/container/inlined_vector.h"
 #include "absl/types/optional.h"
 
+#include <grpc/grpc.h>
+
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/gpr/time_precise.h"
-#include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -134,19 +134,19 @@ class CallCountingHelper {
     // Define the ctors so that we can use this structure in InlinedVector.
     AtomicCounterData() = default;
     AtomicCounterData(const AtomicCounterData& that)
-        : calls_started(that.calls_started.Load(MemoryOrder::RELAXED)),
-          calls_succeeded(that.calls_succeeded.Load(MemoryOrder::RELAXED)),
-          calls_failed(that.calls_failed.Load(MemoryOrder::RELAXED)),
+        : calls_started(that.calls_started.load(std::memory_order_relaxed)),
+          calls_succeeded(that.calls_succeeded.load(std::memory_order_relaxed)),
+          calls_failed(that.calls_failed.load(std::memory_order_relaxed)),
           last_call_started_cycle(
-              that.last_call_started_cycle.Load(MemoryOrder::RELAXED)) {}
+              that.last_call_started_cycle.load(std::memory_order_relaxed)) {}
 
-    Atomic<int64_t> calls_started{0};
-    Atomic<int64_t> calls_succeeded{0};
-    Atomic<int64_t> calls_failed{0};
-    Atomic<gpr_cycle_counter> last_call_started_cycle{0};
+    std::atomic<int64_t> calls_started{0};
+    std::atomic<int64_t> calls_succeeded{0};
+    std::atomic<int64_t> calls_failed{0};
+    std::atomic<gpr_cycle_counter> last_call_started_cycle{0};
     // Make sure the size is exactly one cache line.
-    uint8_t padding[GPR_CACHELINE_SIZE - 3 * sizeof(Atomic<intptr_t>) -
-                    sizeof(Atomic<gpr_cycle_counter>)];
+    uint8_t padding[GPR_CACHELINE_SIZE - 3 * sizeof(std::atomic<intptr_t>) -
+                    sizeof(std::atomic<gpr_cycle_counter>)];
   };
   // TODO(soheilhy,veblush): Revist this after abseil integration.
   // This has a problem when using abseil inlined_vector because it
@@ -220,7 +220,7 @@ class ChannelNode : public BaseNode {
 
   // Least significant bit indicates whether the value is set.  Remaining
   // bits are a grpc_connectivity_state value.
-  Atomic<int> connectivity_state_{0};
+  std::atomic<int> connectivity_state_{0};
 
   Mutex child_mu_;  // Guards sets below.
   std::set<intptr_t> child_channels_;
@@ -310,30 +310,30 @@ class SocketNode : public BaseNode {
   void RecordStreamStartedFromLocal();
   void RecordStreamStartedFromRemote();
   void RecordStreamSucceeded() {
-    streams_succeeded_.FetchAdd(1, MemoryOrder::RELAXED);
+    streams_succeeded_.fetch_add(1, std::memory_order_relaxed);
   }
   void RecordStreamFailed() {
-    streams_failed_.FetchAdd(1, MemoryOrder::RELAXED);
+    streams_failed_.fetch_add(1, std::memory_order_relaxed);
   }
   void RecordMessagesSent(uint32_t num_sent);
   void RecordMessageReceived();
   void RecordKeepaliveSent() {
-    keepalives_sent_.FetchAdd(1, MemoryOrder::RELAXED);
+    keepalives_sent_.fetch_add(1, std::memory_order_relaxed);
   }
 
   const std::string& remote() { return remote_; }
 
  private:
-  Atomic<int64_t> streams_started_{0};
-  Atomic<int64_t> streams_succeeded_{0};
-  Atomic<int64_t> streams_failed_{0};
-  Atomic<int64_t> messages_sent_{0};
-  Atomic<int64_t> messages_received_{0};
-  Atomic<int64_t> keepalives_sent_{0};
-  Atomic<gpr_cycle_counter> last_local_stream_created_cycle_{0};
-  Atomic<gpr_cycle_counter> last_remote_stream_created_cycle_{0};
-  Atomic<gpr_cycle_counter> last_message_sent_cycle_{0};
-  Atomic<gpr_cycle_counter> last_message_received_cycle_{0};
+  std::atomic<int64_t> streams_started_{0};
+  std::atomic<int64_t> streams_succeeded_{0};
+  std::atomic<int64_t> streams_failed_{0};
+  std::atomic<int64_t> messages_sent_{0};
+  std::atomic<int64_t> messages_received_{0};
+  std::atomic<int64_t> keepalives_sent_{0};
+  std::atomic<gpr_cycle_counter> last_local_stream_created_cycle_{0};
+  std::atomic<gpr_cycle_counter> last_remote_stream_created_cycle_{0};
+  std::atomic<gpr_cycle_counter> last_message_sent_cycle_{0};
+  std::atomic<gpr_cycle_counter> last_message_received_cycle_{0};
   std::string local_;
   std::string remote_;
   RefCountedPtr<Security> const security_;

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

@@ -18,23 +18,24 @@
 
 #include <grpc/impl/codegen/port_platform.h>
 
+#include "src/core/lib/channel/channelz_registry.h"
+
 #include <algorithm>
 #include <cstring>
 
 #include "absl/container/inlined_vector.h"
 
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+#include <grpc/support/sync.h>
+
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/channelz.h"
-#include "src/core/lib/channel/channelz_registry.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/sync.h"
 
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-#include <grpc/support/sync.h>
-
 namespace grpc_core {
 namespace channelz {
 namespace {

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

@@ -28,6 +28,7 @@
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/transport/transport.h"

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

@@ -18,6 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/channel/handshaker.h"
+
 #include <string.h>
 
 #include "absl/strings/str_format.h"
@@ -28,7 +30,6 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/handshaker.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/slice/slice_internal.h"

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

@@ -23,9 +23,8 @@
 
 #include "absl/container/inlined_vector.h"
 
-#include <grpc/support/string_util.h>
-
 #include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/support/string_util.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/ref_counted.h"

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

@@ -23,12 +23,20 @@
 
 #include <grpc/impl/codegen/grpc_types.h>
 
-#include "src/core/lib/channel/handshaker.h"
-
 // A handshaker factory is used to create handshakers.
 
+// TODO(ctiller): grpc_pollset_set and HandshakeManager are forward declared in
+// this file. grpc_pollset_set ought to be eliminated when EventEngine lands IO
+// support. At the same time, we ought to be able to include handshake_manager.h
+// here and eliminate the HandshakeManager dependency - we cannot right now
+// because HandshakeManager names too many iomgr types.
+
+typedef struct grpc_pollset_set grpc_pollset_set;
+
 namespace grpc_core {
 
+class HandshakeManager;
+
 class HandshakerFactory {
  public:
   virtual void AddHandshakers(const grpc_channel_args* args,

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

@@ -18,88 +18,33 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/container/inlined_vector.h"
-
 #include "src/core/lib/channel/handshaker_registry.h"
-#include "src/core/lib/gpr/alloc.h"
-#include "src/core/lib/gprpp/memory.h"
-
-#include <string.h>
-#include <algorithm>
-
-#include <grpc/support/alloc.h>
-
-//
-// grpc_handshaker_factory_list
-//
 
 namespace grpc_core {
 
-namespace {
-
-class HandshakerFactoryList {
- public:
-  void Register(bool at_start, std::unique_ptr<HandshakerFactory> factory);
-  void AddHandshakers(const grpc_channel_args* args,
-                      grpc_pollset_set* interested_parties,
-                      HandshakeManager* handshake_mgr);
-
- private:
-  absl::InlinedVector<std::unique_ptr<HandshakerFactory>, 2> factories_;
-};
-
-HandshakerFactoryList* g_handshaker_factory_lists = nullptr;
-
-}  // namespace
-
-void HandshakerFactoryList::Register(
-    bool at_start, std::unique_ptr<HandshakerFactory> factory) {
-  factories_.push_back(std::move(factory));
-  if (at_start) {
-    auto* end = &factories_[factories_.size() - 1];
-    std::rotate(&factories_[0], end, end + 1);
-  }
+void HandshakerRegistry::Builder::RegisterHandshakerFactory(
+    bool at_start, HandshakerType handshaker_type,
+    std::unique_ptr<HandshakerFactory> factory) {
+  auto& vec = factories_[handshaker_type];
+  auto where = at_start ? vec.begin() : vec.end();
+  vec.insert(where, std::move(factory));
 }
 
-void HandshakerFactoryList::AddHandshakers(const grpc_channel_args* args,
-                                           grpc_pollset_set* interested_parties,
-                                           HandshakeManager* handshake_mgr) {
-  for (size_t idx = 0; idx < factories_.size(); ++idx) {
-    auto& handshaker_factory = factories_[idx];
-    handshaker_factory->AddHandshakers(args, interested_parties, handshake_mgr);
+HandshakerRegistry HandshakerRegistry::Builder::Build() {
+  HandshakerRegistry out;
+  for (size_t i = 0; i < NUM_HANDSHAKER_TYPES; i++) {
+    out.factories_[i] = std::move(factories_[i]);
   }
-}
-
-//
-// plugin
-//
-
-void HandshakerRegistry::Init() {
-  GPR_ASSERT(g_handshaker_factory_lists == nullptr);
-  g_handshaker_factory_lists = new HandshakerFactoryList[NUM_HANDSHAKER_TYPES];
-}
-
-void HandshakerRegistry::Shutdown() {
-  GPR_ASSERT(g_handshaker_factory_lists != nullptr);
-  delete[] g_handshaker_factory_lists;
-  g_handshaker_factory_lists = nullptr;
-}
-
-void HandshakerRegistry::RegisterHandshakerFactory(
-    bool at_start, HandshakerType handshaker_type,
-    std::unique_ptr<HandshakerFactory> factory) {
-  GPR_ASSERT(g_handshaker_factory_lists != nullptr);
-  auto& factory_list = g_handshaker_factory_lists[handshaker_type];
-  factory_list.Register(at_start, std::move(factory));
+  return out;
 }
 
 void HandshakerRegistry::AddHandshakers(HandshakerType handshaker_type,
                                         const grpc_channel_args* args,
                                         grpc_pollset_set* interested_parties,
-                                        HandshakeManager* handshake_mgr) {
-  GPR_ASSERT(g_handshaker_factory_lists != nullptr);
-  auto& factory_list = g_handshaker_factory_lists[handshaker_type];
-  factory_list.AddHandshakers(args, interested_parties, handshake_mgr);
+                                        HandshakeManager* handshake_mgr) const {
+  for (const auto& factory : factories_[handshaker_type]) {
+    factory->AddHandshakers(args, interested_parties, handshake_mgr);
+  }
 }
 
 }  // namespace grpc_core