grpc 1.48.0-x86_64-linux → 1.49.0.pre1-x86_64-linux

data/src/core/lib/service_config/service_config_parser.h

@@ -26,12 +26,10 @@
 #include <utility>
 #include <vector>
 
+#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
-#include <grpc/support/log.h>
-
-#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/json/json.h"
 
 namespace grpc_core {
@@ -54,21 +52,13 @@ class ServiceConfigParser {
 
     virtual absl::string_view name() const = 0;
 
-    virtual std::unique_ptr<ParsedConfig> ParseGlobalParams(
-        const grpc_channel_args*, const Json& /* json */,
-        grpc_error_handle* error) {
-      // Avoid unused parameter warning on debug-only parameter
-      (void)error;
-      GPR_DEBUG_ASSERT(error != nullptr);
+    virtual absl::StatusOr<std::unique_ptr<ParsedConfig>> ParseGlobalParams(
+        const ChannelArgs& /*args*/, const Json& /*json*/) {
       return nullptr;
     }
 
-    virtual std::unique_ptr<ParsedConfig> ParsePerMethodParams(
-        const grpc_channel_args*, const Json& /* json */,
-        grpc_error_handle* error) {
-      // Avoid unused parameter warning on debug-only parameter
-      (void)error;
-      GPR_DEBUG_ASSERT(error != nullptr);
+    virtual absl::StatusOr<std::unique_ptr<ParsedConfig>> ParsePerMethodParams(
+        const ChannelArgs& /*args*/, const Json& /*json*/) {
       return nullptr;
     }
   };
@@ -90,13 +80,11 @@ class ServiceConfigParser {
     ServiceConfigParserList registered_parsers_;
   };
 
-  ParsedConfigVector ParseGlobalParameters(const grpc_channel_args* args,
-                                           const Json& json,
-                                           grpc_error_handle* error) const;
+  absl::StatusOr<ParsedConfigVector> ParseGlobalParameters(
+      const ChannelArgs& args, const Json& json) const;
 
-  ParsedConfigVector ParsePerMethodParameters(const grpc_channel_args* args,
-                                              const Json& json,
-                                              grpc_error_handle* error) const;
+  absl::StatusOr<ParsedConfigVector> ParsePerMethodParameters(
+      const ChannelArgs& args, const Json& json) const;
 
   // Return the index for a given registered parser.
   // If there is an error, return -1.

data/src/core/lib/slice/percent_encoding.cc

@@ -23,27 +23,18 @@
 #include <stdlib.h>
 
 #include <cstdint>
-#include <type_traits>
 #include <utility>
 
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/bitset.h"
 
-#if __cplusplus > 201103l
-#define GRPC_PCTENCODE_CONSTEXPR_FN constexpr
-#define GRPC_PCTENCODE_CONSTEXPR_VALUE constexpr
-#else
-#define GRPC_PCTENCODE_CONSTEXPR_FN
-#define GRPC_PCTENCODE_CONSTEXPR_VALUE const
-#endif
-
 namespace grpc_core {
 
 namespace {
 class UrlTable : public BitSet<256> {
  public:
-  GRPC_PCTENCODE_CONSTEXPR_FN UrlTable() {
+  constexpr UrlTable() {
     for (int i = 'a'; i <= 'z'; i++) set(i);
     for (int i = 'A'; i <= 'Z'; i++) set(i);
     for (int i = '0'; i <= '9'; i++) set(i);
@@ -54,11 +45,11 @@ class UrlTable : public BitSet<256> {
   }
 };
 
-GRPC_PCTENCODE_CONSTEXPR_VALUE UrlTable g_url_table;
+constexpr UrlTable g_url_table;
 
 class CompatibleTable : public BitSet<256> {
  public:
-  GRPC_PCTENCODE_CONSTEXPR_FN CompatibleTable() {
+  constexpr CompatibleTable() {
     for (int i = 32; i <= 126; i++) {
       if (i == '%') continue;
       set(i);
@@ -66,7 +57,7 @@ class CompatibleTable : public BitSet<256> {
   }
 };
 
-GRPC_PCTENCODE_CONSTEXPR_VALUE CompatibleTable g_compatible_table;
+constexpr CompatibleTable g_compatible_table;
 
 // Map PercentEncodingType to a lookup table of legal symbols for that encoding.
 const BitSet<256>& LookupTableForPercentEncodingType(PercentEncodingType type) {

data/src/core/lib/slice/slice.cc

@@ -148,6 +148,12 @@ class MovedCppStringSliceRefCount : public grpc_slice_refcount {
   explicit MovedCppStringSliceRefCount(std::string&& str)
       : grpc_slice_refcount(Destroy), str_(std::move(str)) {}
 
+  uint8_t* data() {
+    return reinterpret_cast<uint8_t*>(const_cast<char*>(str_.data()));
+  }
+
+  size_t size() const { return str_.size(); }
+
  private:
   static void Destroy(grpc_slice_refcount* arg) {
     delete static_cast<MovedCppStringSliceRefCount*>(arg);
@@ -206,10 +212,10 @@ grpc_slice grpc_slice_from_cpp_string(std::string str) {
     slice.data.inlined.length = str.size();
     memcpy(GRPC_SLICE_START_PTR(slice), str.data(), str.size());
   } else {
-    slice.data.refcounted.bytes =
-        reinterpret_cast<uint8_t*>(const_cast<char*>(str.data()));
-    slice.data.refcounted.length = str.size();
-    slice.refcount = new grpc_core::MovedCppStringSliceRefCount(std::move(str));
+    auto* refcount = new grpc_core::MovedCppStringSliceRefCount(std::move(str));
+    slice.data.refcounted.bytes = refcount->data();
+    slice.data.refcounted.length = refcount->size();
+    slice.refcount = refcount;
   }
   return slice;
 }

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

@@ -1415,10 +1415,16 @@ grpc_call_error FilterStackCall::StartBatch(const grpc_op* ops, size_t nops,
         if (is_client() && send_deadline() != Timestamp::InfFuture()) {
           send_initial_metadata_.Set(GrpcTimeoutMetadata(), send_deadline());
         }
+        if (is_client()) {
+          send_initial_metadata_.Set(
+              WaitForReady(),
+              WaitForReady::ValueType{
+                  (op->flags & GRPC_INITIAL_METADATA_WAIT_FOR_READY) != 0,
+                  (op->flags &
+                   GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET) != 0});
+        }
         stream_op_payload->send_initial_metadata.send_initial_metadata =
             &send_initial_metadata_;
-        stream_op_payload->send_initial_metadata.send_initial_metadata_flags =
-            op->flags;
         if (is_client()) {
           stream_op_payload->send_initial_metadata.peer_string = &peer_string_;
         }

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

@@ -62,7 +62,8 @@
 
 namespace grpc_core {
 
-Channel::Channel(bool is_client, std::string target, ChannelArgs channel_args,
+Channel::Channel(bool is_client, std::string target,
+                 const ChannelArgs& channel_args,
                  grpc_compression_options compression_options,
                  RefCountedPtr<grpc_channel_stack> channel_stack)
     : is_client_(is_client),
@@ -149,8 +150,8 @@ absl::StatusOr<RefCountedPtr<Channel>> Channel::CreateWithBuilder(
 
   return RefCountedPtr<Channel>(new Channel(
       grpc_channel_stack_type_is_client(builder->channel_stack_type()),
-      std::string(builder->target()), std::move(channel_args),
-      compression_options, std::move(*r)));
+      std::string(builder->target()), channel_args, compression_options,
+      std::move(*r)));
 }
 
 namespace {
@@ -219,9 +220,8 @@ absl::StatusOr<RefCountedPtr<Channel>> Channel::Create(
       args = channel_args_mutator(target, args, channel_stack_type);
     }
   }
-  builder.SetChannelArgs(std::move(args))
-      .SetTarget(target)
-      .SetTransport(optional_transport);
+  builder.SetChannelArgs(args).SetTarget(target).SetTransport(
+      optional_transport);
   if (!CoreConfiguration::Get().channel_init().CreateStack(&builder)) {
     return nullptr;
   }

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

@@ -154,7 +154,7 @@ class Channel : public RefCounted<Channel>,
   }
 
  private:
-  Channel(bool is_client, std::string target, ChannelArgs channel_args,
+  Channel(bool is_client, std::string target, const ChannelArgs& channel_args,
           grpc_compression_options compression_options,
           RefCountedPtr<grpc_channel_stack> channel_stack);
 

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

@@ -447,8 +447,6 @@ grpc_core::TraceFlag grpc_cq_pluck_trace(false, "queue_pluck");
 
 static void on_pollset_shutdown_done(void* arg, grpc_error_handle error);
 
-void grpc_cq_global_init() {}
-
 void grpc_completion_queue_thread_local_cache_init(grpc_completion_queue* cq) {
   if (g_cached_cq == nullptr) {
     g_cached_event = nullptr;

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

@@ -71,9 +71,6 @@ void grpc_cq_internal_unref(grpc_completion_queue* cq);
 #define GRPC_CQ_INTERNAL_UNREF(cq, reason) grpc_cq_internal_unref(cq)
 #endif
 
-/* Initializes global variables used by completion queues */
-void grpc_cq_global_init();
-
 /* Flag that an operation is beginning: the completion channel will not finish
    shutdown until a corrensponding grpc_cq_end_* call is made.
    \a tag is currently used only in debug builds. Return true on success, and

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

@@ -36,13 +36,12 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/debug/stats.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/event_engine/forkable.h"
 #include "src/core/lib/gprpp/fork.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/timer_manager.h"
 #include "src/core/lib/profiling/timers.h"
@@ -53,7 +52,6 @@
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/channel_stack_type.h"
-#include "src/core/lib/surface/completion_queue.h"
 
 /* (generated) built in registry of plugins */
 extern void grpc_register_built_in_plugins(void);
@@ -120,8 +118,6 @@ static void do_basic_init(void) {
   g_init_mu = new grpc_core::Mutex();
   g_shutting_down_cv = new grpc_core::CondVar();
   grpc_register_built_in_plugins();
-  grpc_cq_global_init();
-  grpc_core::grpc_executor_global_init();
   gpr_time_init();
 }
 
@@ -152,8 +148,8 @@ void grpc_init(void) {
       g_shutting_down_cv->SignalAll();
     }
     grpc_core::Fork::GlobalInit();
+    grpc_event_engine::experimental::RegisterForkHandlers();
     grpc_fork_handlers_auto_register();
-    grpc_stats_init();
     grpc_core::ApplicationCallbackExecCtx::GlobalInit();
     grpc_iomgr_init();
     gpr_timers_global_init();

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

@@ -80,7 +80,6 @@ struct Server::RequestedCall {
         cq_bound_to_call(call_cq),
         call(call_arg),
         initial_metadata(initial_md) {
-    details->reserved = nullptr;
     data.batch.details = details;
   }
 
@@ -520,7 +519,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 +538,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 +603,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());
   }
@@ -1250,7 +1249,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 +1347,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_ =

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

@@ -124,12 +124,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 +161,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 +341,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;
@@ -443,7 +442,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_;
 
@@ -500,8 +499,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 "27.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "garum"; }
+const char* grpc_g_stands_for(void) { return "gamma"; }

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: