grpc 1.48.0 → 1.50.0

data/src/core/lib/surface/lame_client.cc

@@ -42,7 +42,6 @@
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/channel.h"
@@ -61,8 +60,8 @@ const grpc_channel_filter LameClientFilter::kFilter =
     MakePromiseBasedFilter<LameClientFilter, FilterEndpoint::kClient,
                            kFilterIsLast>("lame-client");
 
-absl::StatusOr<LameClientFilter> LameClientFilter::Create(ChannelArgs args,
-                                                          ChannelFilter::Args) {
+absl::StatusOr<LameClientFilter> LameClientFilter::Create(
+    const ChannelArgs& args, ChannelFilter::Args) {
   return LameClientFilter(
       *args.GetPointer<absl::Status>(GRPC_ARG_LAME_FILTER_ERROR));
 }

data/src/core/lib/surface/lame_client.h

@@ -49,7 +49,7 @@ class LameClientFilter : public ChannelFilter {
   static const grpc_channel_filter kFilter;
 
   static absl::StatusOr<LameClientFilter> Create(
-      ChannelArgs args, ChannelFilter::Args filter_args);
+      const ChannelArgs& args, ChannelFilter::Args filter_args);
   ArenaPromise<ServerMetadataHandle> MakeCallPromise(
       CallArgs call_args, NextPromiseFactory next_promise_factory) override;
   bool StartTransportOp(grpc_transport_op*) override;

data/src/core/lib/surface/server.cc

@@ -45,7 +45,6 @@
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/debug/stats.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/mpscq.h"
@@ -80,7 +79,6 @@ struct Server::RequestedCall {
         cq_bound_to_call(call_cq),
         call(call_arg),
         initial_metadata(initial_md) {
-    details->reserved = nullptr;
     data.batch.details = details;
   }
 
@@ -276,14 +274,12 @@ class Server::RealRequestMatcher : public RequestMatcherInterface {
       RequestedCall* rc =
           reinterpret_cast<RequestedCall*>(requests_per_cq_[cq_idx].TryPop());
       if (rc != nullptr) {
-        GRPC_STATS_INC_SERVER_CQS_CHECKED(i);
         calld->SetState(CallData::CallState::ACTIVATED);
         calld->Publish(cq_idx, rc);
         return;
       }
     }
     // No cq to take the request found; queue it on the slow list.
-    GRPC_STATS_INC_SERVER_SLOWPATH_REQUESTS_QUEUED();
     // We need to ensure that all the queues are empty.  We do this under
     // the server mu_call_ lock to ensure that if something is added to
     // an empty request queue, it will block until the call is actually
@@ -307,7 +303,6 @@ class Server::RealRequestMatcher : public RequestMatcherInterface {
         return;
       }
     }
-    GRPC_STATS_INC_SERVER_CQS_CHECKED(loop_count + requests_per_cq_.size());
     calld->SetState(CallData::CallState::ACTIVATED);
     calld->Publish(cq_idx, rc);
   }
@@ -520,7 +515,8 @@ const grpc_channel_filter Server::kServerTopFilter = {
 
 namespace {
 
-RefCountedPtr<channelz::ServerNode> CreateChannelzNode(ChannelArgs args) {
+RefCountedPtr<channelz::ServerNode> CreateChannelzNode(
+    const ChannelArgs& args) {
   RefCountedPtr<channelz::ServerNode> channelz_node;
   if (args.GetBool(GRPC_ARG_ENABLE_CHANNELZ)
           .value_or(GRPC_ENABLE_CHANNELZ_DEFAULT)) {
@@ -538,11 +534,10 @@ RefCountedPtr<channelz::ServerNode> CreateChannelzNode(ChannelArgs args) {
 
 }  // namespace
 
-Server::Server(ChannelArgs args)
-    : channel_args_(args.ToC()), channelz_node_(CreateChannelzNode(args)) {}
+Server::Server(const ChannelArgs& args)
+    : channel_args_(args), channelz_node_(CreateChannelzNode(args)) {}
 
 Server::~Server() {
-  grpc_channel_args_destroy(channel_args_);
   // Remove the cq pollsets from the config_fetcher.
   if (started_ && config_fetcher_ != nullptr &&
       config_fetcher_->interested_parties() != nullptr) {
@@ -604,11 +599,11 @@ void Server::Start() {
 
 grpc_error_handle Server::SetupTransport(
     grpc_transport* transport, grpc_pollset* accepting_pollset,
-    const grpc_channel_args* args,
+    const ChannelArgs& args,
     const RefCountedPtr<channelz::SocketNode>& socket_node) {
   // Create channel.
-  absl::StatusOr<RefCountedPtr<Channel>> channel = Channel::Create(
-      nullptr, ChannelArgs::FromC(args), GRPC_SERVER_CHANNEL, transport);
+  absl::StatusOr<RefCountedPtr<Channel>> channel =
+      Channel::Create(nullptr, args, GRPC_SERVER_CHANNEL, transport);
   if (!channel.ok()) {
     return absl_status_to_grpc_error(channel.status());
   }
@@ -795,7 +790,7 @@ void DonePublishedShutdown(void* /*done_arg*/, grpc_cq_completion* storage) {
 //       connection is NOT closed until the server is done with all those calls.
 //    -- Once there are no more calls in progress, the channel is closed.
 void Server::ShutdownAndNotify(grpc_completion_queue* cq, void* tag) {
-  absl::Notification* await_requests = nullptr;
+  Notification* await_requests = nullptr;
   ChannelBroadcaster broadcaster;
   {
     // Wait for startup to be finished.  Locks mu_global.
@@ -1250,7 +1245,6 @@ void Server::CallData::Publish(size_t cq_idx, RequestedCall* rc) {
           grpc_slice_ref_internal(path_->c_slice());
       rc->data.batch.details->deadline =
           deadline_.as_timespec(GPR_CLOCK_MONOTONIC);
-      rc->data.batch.details->flags = recv_initial_metadata_flags_;
       break;
     case RequestedCall::Type::REGISTERED_CALL:
       *rc->data.registered.deadline =
@@ -1349,15 +1343,12 @@ void Server::CallData::RecvInitialMetadataBatchComplete(
 void Server::CallData::StartTransportStreamOpBatchImpl(
     grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
   if (batch->recv_initial_metadata) {
-    GPR_ASSERT(batch->payload->recv_initial_metadata.recv_flags == nullptr);
     recv_initial_metadata_ =
         batch->payload->recv_initial_metadata.recv_initial_metadata;
     original_recv_initial_metadata_ready_ =
         batch->payload->recv_initial_metadata.recv_initial_metadata_ready;
     batch->payload->recv_initial_metadata.recv_initial_metadata_ready =
         &recv_initial_metadata_ready_;
-    batch->payload->recv_initial_metadata.recv_flags =
-        &recv_initial_metadata_flags_;
   }
   if (batch->recv_trailing_metadata) {
     original_recv_trailing_metadata_ready_ =
@@ -1530,7 +1521,6 @@ grpc_call_error grpc_server_request_call(
     grpc_completion_queue* cq_for_notification, void* tag) {
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
-  GRPC_STATS_INC_SERVER_REQUESTED_CALLS();
   GRPC_API_TRACE(
       "grpc_server_request_call("
       "server=%p, call=%p, details=%p, initial_metadata=%p, "
@@ -1551,7 +1541,6 @@ grpc_call_error grpc_server_request_registered_call(
     grpc_completion_queue* cq_for_notification, void* tag_new) {
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
-  GRPC_STATS_INC_SERVER_REQUESTED_CALLS();
   auto* rm =
       static_cast<grpc_core::Server::RegisteredMethod*>(registered_method);
   GRPC_API_TRACE(

data/src/core/lib/surface/server.h

@@ -33,7 +33,6 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/memory/memory.h"
 #include "absl/status/statusor.h"
-#include "absl/synchronization/notification.h"
 #include "absl/types/optional.h"
 
 #include <grpc/grpc.h>
@@ -49,6 +48,7 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/cpp_impl_of.h"
 #include "src/core/lib/gprpp/dual_ref_counted.h"
+#include "src/core/lib/gprpp/notification.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -58,7 +58,6 @@
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
-#include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/completion_queue.h"
@@ -124,12 +123,12 @@ class Server : public InternallyRefCounted<Server>,
     virtual void SetOnDestroyDone(grpc_closure* on_destroy_done) = 0;
   };
 
-  explicit Server(ChannelArgs args);
+  explicit Server(const ChannelArgs& args);
   ~Server() override;
 
   void Orphan() ABSL_LOCKS_EXCLUDED(mu_global_) override;
 
-  const grpc_channel_args* channel_args() const { return channel_args_; }
+  const ChannelArgs& channel_args() const { return channel_args_; }
   channelz::ServerNode* channelz_node() const { return channelz_node_.get(); }
 
   // Do not call this before Start(). Returns the pollsets. The
@@ -161,7 +160,7 @@ class Server : public InternallyRefCounted<Server>,
   // Takes ownership of a ref on resource_user from the caller.
   grpc_error_handle SetupTransport(
       grpc_transport* transport, grpc_pollset* accepting_pollset,
-      const grpc_channel_args* args,
+      const ChannelArgs& args,
       const RefCountedPtr<channelz::SocketNode>& socket_node);
 
   void RegisterCompletionQueue(grpc_completion_queue* cq);
@@ -341,7 +340,6 @@ class Server : public InternallyRefCounted<Server>,
     grpc_closure recv_initial_metadata_batch_complete_;
 
     grpc_metadata_batch* recv_initial_metadata_ = nullptr;
-    uint32_t recv_initial_metadata_flags_ = 0;
     grpc_closure recv_initial_metadata_ready_;
     grpc_closure* original_recv_initial_metadata_ready_;
     grpc_error_handle recv_initial_metadata_error_ = GRPC_ERROR_NONE;
@@ -421,14 +419,14 @@ class Server : public InternallyRefCounted<Server>,
   }
   // Returns a notification pointer to wait on if there are requests in-flight,
   // or null.
-  absl::Notification* ShutdownUnrefOnShutdownCall()
+  Notification* ShutdownUnrefOnShutdownCall()
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_global_) GRPC_MUST_USE_RESULT {
     if (shutdown_refs_.fetch_sub(1, std::memory_order_acq_rel) == 1) {
       // There is no request in-flight.
       MaybeFinishShutdown();
       return nullptr;
     }
-    requests_complete_ = absl::make_unique<absl::Notification>();
+    requests_complete_ = absl::make_unique<Notification>();
     return requests_complete_.get();
   }
 
@@ -443,7 +441,7 @@ class Server : public InternallyRefCounted<Server>,
     return shutdown_refs_.load(std::memory_order_acquire) == 0;
   }
 
-  const grpc_channel_args* const channel_args_;
+  ChannelArgs const channel_args_;
   RefCountedPtr<channelz::ServerNode> channelz_node_;
   std::unique_ptr<grpc_server_config_fetcher> config_fetcher_;
 
@@ -480,8 +478,7 @@ class Server : public InternallyRefCounted<Server>,
   std::atomic<int> shutdown_refs_{1};
   bool shutdown_published_ ABSL_GUARDED_BY(mu_global_) = false;
   std::vector<ShutdownTag> shutdown_tags_ ABSL_GUARDED_BY(mu_global_);
-  std::unique_ptr<absl::Notification> requests_complete_
-      ABSL_GUARDED_BY(mu_global_);
+  std::unique_ptr<Notification> requests_complete_ ABSL_GUARDED_BY(mu_global_);
 
   std::list<ChannelData*> channels_;
 
@@ -500,8 +497,9 @@ struct grpc_server_config_fetcher {
       : public grpc_core::DualRefCounted<ConnectionManager> {
    public:
     // Ownership of \a args is transfered.
-    virtual absl::StatusOr<grpc_channel_args*> UpdateChannelArgsForConnection(
-        grpc_channel_args* args, grpc_endpoint* tcp) = 0;
+    virtual absl::StatusOr<grpc_core::ChannelArgs>
+    UpdateChannelArgsForConnection(const grpc_core::ChannelArgs& args,
+                                   grpc_endpoint* tcp) = 0;
   };
 
   class WatcherInterface {

data/src/core/lib/surface/validate_metadata.cc

@@ -29,14 +29,6 @@
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/error.h"
 
-#if __cplusplus > 201103l
-#define GRPC_VALIDATE_METADATA_CONSTEXPR_FN constexpr
-#define GRPC_VALIDATE_METADATA_CONSTEXPR_VALUE constexpr
-#else
-#define GRPC_VALIDATE_METADATA_CONSTEXPR_FN
-#define GRPC_VALIDATE_METADATA_CONSTEXPR_VALUE const
-#endif
-
 static grpc_error_handle conforms_to(const grpc_slice& slice,
                                      const grpc_core::BitSet<256>& legal_bits,
                                      const char* err_desc) {
@@ -68,7 +60,7 @@ static int error2int(grpc_error_handle error) {
 namespace {
 class LegalHeaderKeyBits : public grpc_core::BitSet<256> {
  public:
-  GRPC_VALIDATE_METADATA_CONSTEXPR_FN LegalHeaderKeyBits() {
+  constexpr LegalHeaderKeyBits() {
     for (int i = 'a'; i <= 'z'; i++) set(i);
     for (int i = '0'; i <= '9'; i++) set(i);
     set('-');
@@ -76,8 +68,7 @@ class LegalHeaderKeyBits : public grpc_core::BitSet<256> {
     set('.');
   }
 };
-GRPC_VALIDATE_METADATA_CONSTEXPR_VALUE LegalHeaderKeyBits
-    g_legal_header_key_bits;
+constexpr LegalHeaderKeyBits g_legal_header_key_bits;
 }  // namespace
 
 grpc_error_handle grpc_validate_header_key_is_legal(const grpc_slice& slice) {
@@ -103,14 +94,13 @@ int grpc_header_key_is_legal(grpc_slice slice) {
 namespace {
 class LegalHeaderNonBinValueBits : public grpc_core::BitSet<256> {
  public:
-  GRPC_VALIDATE_METADATA_CONSTEXPR_FN LegalHeaderNonBinValueBits() {
+  constexpr LegalHeaderNonBinValueBits() {
     for (int i = 32; i <= 126; i++) {
       set(i);
     }
   }
 };
-GRPC_VALIDATE_METADATA_CONSTEXPR_VALUE LegalHeaderNonBinValueBits
-    g_legal_header_non_bin_value_bits;
+constexpr LegalHeaderNonBinValueBits g_legal_header_non_bin_value_bits;
 }  // namespace
 
 grpc_error_handle grpc_validate_header_nonbin_value_is_legal(

data/src/core/lib/surface/version.cc

@@ -23,6 +23,6 @@
 
 #include <grpc/grpc.h>
 
-const char* grpc_version_string(void) { return "26.0.0"; }
+const char* grpc_version_string(void) { return "28.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "garum"; }
+const char* grpc_g_stands_for(void) { return "galley"; }

data/src/core/lib/transport/bdp_estimator.cc

@@ -25,8 +25,6 @@
 
 #include <algorithm>
 
-#include "src/core/lib/iomgr/exec_ctx.h"
-
 grpc_core::TraceFlag grpc_bdp_estimator_trace(false, "bdp_estimator");
 
 namespace grpc_core {
@@ -82,7 +80,7 @@ Timestamp BdpEstimator::CompletePing() {
   }
   ping_state_ = PingState::UNSCHEDULED;
   accumulator_ = 0;
-  return ExecCtx::Get()->Now() + inter_ping_delay_;
+  return Timestamp::Now() + inter_ping_delay_;
 }
 
 }  // namespace grpc_core

data/src/core/lib/transport/connectivity_state.cc

@@ -21,7 +21,6 @@
 #include "src/core/lib/transport/connectivity_state.h"
 
 #include <string>
-#include <type_traits>
 
 #include <grpc/support/log.h>
 

data/src/core/lib/transport/connectivity_state.h

@@ -32,7 +32,7 @@
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/iomgr/work_serializer.h"
+#include "src/core/lib/gprpp/work_serializer.h"
 
 namespace grpc_core {
 

data/src/core/lib/transport/error_utils.cc

@@ -31,10 +31,6 @@
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/transport/status_conversion.h"
 
-#ifndef GRPC_ERROR_IS_ABSEIL_STATUS
-#include "src/core/lib/iomgr/error_internal.h"
-#endif
-
 static grpc_error_handle recursively_find_error_with_field(
     grpc_error_handle error, grpc_error_ints which) {
   intptr_t unused;
@@ -42,25 +38,11 @@ static grpc_error_handle recursively_find_error_with_field(
   if (grpc_error_get_int(error, which, &unused)) {
     return error;
   }
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
   std::vector<absl::Status> children = grpc_core::StatusGetChildren(error);
   for (const absl::Status& child : children) {
     grpc_error_handle result = recursively_find_error_with_field(child, which);
     if (!GRPC_ERROR_IS_NONE(result)) return result;
   }
-#else
-  if (grpc_error_is_special(error)) return GRPC_ERROR_NONE;
-  // Otherwise, search through its children.
-  uint8_t slot = error->first_err;
-  while (slot != UINT8_MAX) {
-    grpc_linked_error* lerr =
-        reinterpret_cast<grpc_linked_error*>(error->arena + slot);
-    grpc_error_handle result =
-        recursively_find_error_with_field(lerr->err, which);
-    if (result) return result;
-    slot = lerr->next;
-  }
-#endif
   return GRPC_ERROR_NONE;
 }
 
@@ -113,9 +95,7 @@ void grpc_error_get_status(grpc_error_handle error,
     status = grpc_http2_error_to_grpc_status(
         static_cast<grpc_http2_error_code>(integer), deadline);
   } else {
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
     status = static_cast<grpc_status_code>(found_error.code());
-#endif
   }
   if (code != nullptr) *code = status;
 
@@ -143,11 +123,7 @@ void grpc_error_get_status(grpc_error_handle error,
                             message)) {
       if (!grpc_error_get_str(found_error, GRPC_ERROR_STR_DESCRIPTION,
                               message)) {
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
         *message = grpc_error_std_string(error);
-#else
-        *message = "unknown error";
-#endif
       }
     }
   }
@@ -179,23 +155,11 @@ bool grpc_error_has_clear_grpc_status(grpc_error_handle error) {
   if (grpc_error_get_int(error, GRPC_ERROR_INT_GRPC_STATUS, &unused)) {
     return true;
   }
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
   std::vector<absl::Status> children = grpc_core::StatusGetChildren(error);
   for (const absl::Status& child : children) {
     if (grpc_error_has_clear_grpc_status(child)) {
       return true;
     }
   }
-#else
-  uint8_t slot = error->first_err;
-  while (slot != UINT8_MAX) {
-    grpc_linked_error* lerr =
-        reinterpret_cast<grpc_linked_error*>(error->arena + slot);
-    if (grpc_error_has_clear_grpc_status(lerr->err)) {
-      return true;
-    }
-    slot = lerr->next;
-  }
-#endif
   return false;
 }

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

@@ -27,6 +27,7 @@
 
 #include "absl/strings/str_format.h"
 
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -45,14 +46,12 @@ TraceFlag grpc_handshaker_trace(false, "handshaker");
 namespace {
 
 std::string HandshakerArgsString(HandshakerArgs* args) {
-  size_t num_args = args->args != nullptr ? args->args->num_args : 0;
   size_t read_buffer_length =
       args->read_buffer != nullptr ? args->read_buffer->length : 0;
   return absl::StrFormat(
-      "{endpoint=%p, args=%p {size=%" PRIuPTR
-      ": %s}, read_buffer=%p (length=%" PRIuPTR "), exit_early=%d}",
-      args->endpoint, args->args, num_args,
-      grpc_channel_args_string(args->args), args->read_buffer,
+      "{endpoint=%p, args=%s, read_buffer=%p (length=%" PRIuPTR
+      "), exit_early=%d}",
+      args->endpoint, args->args.ToString(), args->read_buffer,
       read_buffer_length, args->exit_early);
 }
 
@@ -115,8 +114,7 @@ bool HandshakeManager::CallNextHandshakerLocked(grpc_error_handle error) {
         grpc_endpoint_shutdown(args_.endpoint, GRPC_ERROR_REF(error));
         grpc_endpoint_destroy(args_.endpoint);
         args_.endpoint = nullptr;
-        grpc_channel_args_destroy(args_.args);
-        args_.args = nullptr;
+        args_.args = ChannelArgs();
         grpc_slice_buffer_destroy_internal(args_.read_buffer);
         gpr_free(args_.read_buffer);
         args_.read_buffer = nullptr;
@@ -172,7 +170,7 @@ void HandshakeManager::OnTimeoutFn(void* arg, grpc_error_handle error) {
 }
 
 void HandshakeManager::DoHandshake(grpc_endpoint* endpoint,
-                                   const grpc_channel_args* channel_args,
+                                   const ChannelArgs& channel_args,
                                    Timestamp deadline,
                                    grpc_tcp_server_acceptor* acceptor,
                                    grpc_iomgr_cb_func on_handshake_done,
@@ -185,7 +183,7 @@ void HandshakeManager::DoHandshake(grpc_endpoint* endpoint,
     // handshakers and eventually be freed by the on_handshake_done callback.
     args_.endpoint = endpoint;
     args_.deadline = deadline;
-    args_.args = grpc_channel_args_copy(channel_args);
+    args_.args = channel_args;
     args_.user_data = user_data;
     args_.read_buffer =
         static_cast<grpc_slice_buffer*>(gpr_malloc(sizeof(*args_.read_buffer)));

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

@@ -25,9 +25,9 @@
 
 #include "absl/container/inlined_vector.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/slice.h>
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -63,7 +63,7 @@ namespace grpc_core {
 /// which the callback takes ownership of.
 struct HandshakerArgs {
   grpc_endpoint* endpoint = nullptr;
-  grpc_channel_args* args = nullptr;
+  ChannelArgs args;
   grpc_slice_buffer* read_buffer = nullptr;
   // A handshaker may set this to true before invoking on_handshake_done
   // to indicate that subsequent handshakers should be skipped.
@@ -120,9 +120,8 @@ class HandshakeManager : public RefCounted<HandshakeManager> {
   /// GRPC_ERROR_NONE, then handshaking failed and the handshaker has done
   /// the necessary clean-up.  Otherwise, the callback takes ownership of
   /// the arguments.
-  void DoHandshake(grpc_endpoint* endpoint,
-                   const grpc_channel_args* channel_args, Timestamp deadline,
-                   grpc_tcp_server_acceptor* acceptor,
+  void DoHandshake(grpc_endpoint* endpoint, const ChannelArgs& channel_args,
+                   Timestamp deadline, grpc_tcp_server_acceptor* acceptor,
                    grpc_iomgr_cb_func on_handshake_done, void* user_data);
 
  private:

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

@@ -21,8 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/impl/codegen/grpc_types.h>
-
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 
 // A handshaker factory is used to create handshakers.
@@ -38,7 +37,7 @@ class HandshakeManager;
 
 class HandshakerFactory {
  public:
-  virtual void AddHandshakers(const grpc_channel_args* args,
+  virtual void AddHandshakers(const ChannelArgs& args,
                               grpc_pollset_set* interested_parties,
                               HandshakeManager* handshake_mgr) = 0;
   virtual ~HandshakerFactory() = default;

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

@@ -22,6 +22,7 @@
 
 #include <stddef.h>
 
+#include <algorithm>
 #include <utility>
 
 namespace grpc_core {
@@ -43,7 +44,7 @@ HandshakerRegistry HandshakerRegistry::Builder::Build() {
 }
 
 void HandshakerRegistry::AddHandshakers(HandshakerType handshaker_type,
-                                        const grpc_channel_args* args,
+                                        const ChannelArgs& args,
                                         grpc_pollset_set* interested_parties,
                                         HandshakeManager* handshake_mgr) const {
   for (const auto& factory : factories_[handshaker_type]) {

data/src/core/lib/transport/handshaker_registry.h

@@ -24,8 +24,7 @@
 #include <memory>
 #include <vector>
 
-#include <grpc/impl/codegen/grpc_types.h>
-
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/transport/handshaker_factory.h"
 
@@ -55,8 +54,7 @@ class HandshakerRegistry {
         factories_[NUM_HANDSHAKER_TYPES];
   };
 
-  void AddHandshakers(HandshakerType handshaker_type,
-                      const grpc_channel_args* args,
+  void AddHandshakers(HandshakerType handshaker_type, const ChannelArgs& args,
                       grpc_pollset_set* interested_parties,
                       HandshakeManager* handshake_mgr) const;
 

data/src/core/lib/transport/http_connect_handshaker.cc

@@ -30,8 +30,8 @@
 #include "absl/memory/memory.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
@@ -118,8 +118,7 @@ void HttpConnectHandshaker::CleanupArgsForFailureLocked() {
   args_->endpoint = nullptr;
   read_buffer_to_destroy_ = args_->read_buffer;
   args_->read_buffer = nullptr;
-  grpc_channel_args_destroy(args_->args);
-  args_->args = nullptr;
+  args_->args = ChannelArgs();
 }
 
 // If the handshake failed or we're shutting down, clean up and invoke the
@@ -297,10 +296,9 @@ void HttpConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
                                         HandshakerArgs* args) {
   // Check for HTTP CONNECT channel arg.
   // If not found, invoke on_handshake_done without doing anything.
-  const grpc_arg* arg =
-      grpc_channel_args_find(args->args, GRPC_ARG_HTTP_CONNECT_SERVER);
-  char* server_name = grpc_channel_arg_get_string(arg);
-  if (server_name == nullptr) {
+  absl::optional<absl::string_view> server_name =
+      args->args.GetString(GRPC_ARG_HTTP_CONNECT_SERVER);
+  if (!server_name.has_value()) {
     // Set shutdown to true so that subsequent calls to
     // http_connect_handshaker_shutdown() do nothing.
     {
@@ -311,14 +309,15 @@ void HttpConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
     return;
   }
   // Get headers from channel args.
-  arg = grpc_channel_args_find(args->args, GRPC_ARG_HTTP_CONNECT_HEADERS);
-  char* arg_header_string = grpc_channel_arg_get_string(arg);
+  absl::optional<absl::string_view> arg_header_string =
+      args->args.GetString(GRPC_ARG_HTTP_CONNECT_HEADERS);
   grpc_http_header* headers = nullptr;
   size_t num_headers = 0;
   char** header_strings = nullptr;
   size_t num_header_strings = 0;
-  if (arg_header_string != nullptr) {
-    gpr_string_split(arg_header_string, "\n", &header_strings,
+  if (arg_header_string.has_value()) {
+    std::string buffer(*arg_header_string);
+    gpr_string_split(buffer.c_str(), "\n", &header_strings,
                      &num_header_strings);
     headers = static_cast<grpc_http_header*>(
         gpr_malloc(sizeof(grpc_http_header) * num_header_strings));
@@ -342,8 +341,9 @@ void HttpConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
   on_handshake_done_ = on_handshake_done;
   // Log connection via proxy.
   std::string proxy_name(grpc_endpoint_get_peer(args->endpoint));
-  gpr_log(GPR_INFO, "Connecting to server %s via HTTP proxy %s", server_name,
-          proxy_name.c_str());
+  std::string server_name_string(*server_name);
+  gpr_log(GPR_INFO, "Connecting to server %s via HTTP proxy %s",
+          server_name_string.c_str(), proxy_name.c_str());
   // Construct HTTP CONNECT request.
   grpc_http_request request;
   request.method = const_cast<char*>("CONNECT");
@@ -352,8 +352,8 @@ void HttpConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
   request.hdr_count = num_headers;
   request.body_length = 0;
   request.body = nullptr;
-  grpc_slice request_slice =
-      grpc_httpcli_format_connect_request(&request, server_name, server_name);
+  grpc_slice request_slice = grpc_httpcli_format_connect_request(
+      &request, server_name_string.c_str(), server_name_string.c_str());
   grpc_slice_buffer_add(&write_buffer_, request_slice);
   // Clean up.
   gpr_free(headers);
@@ -382,7 +382,7 @@ HttpConnectHandshaker::HttpConnectHandshaker() {
 
 class HttpConnectHandshakerFactory : public HandshakerFactory {
  public:
-  void AddHandshakers(const grpc_channel_args* /*args*/,
+  void AddHandshakers(const ChannelArgs& /*args*/,
                       grpc_pollset_set* /*interested_parties*/,
                       HandshakeManager* handshake_mgr) override {
     handshake_mgr->Add(MakeRefCounted<HttpConnectHandshaker>());