grpc 1.47.0 → 1.49.0.pre1

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

@@ -22,11 +22,13 @@
 
 #include <stdint.h>
 
+#include <vector>
+
 #include "absl/strings/string_view.h"
 
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/iomgr/error_internal.h"
+#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/transport/status_conversion.h"
 
 static grpc_error_handle recursively_find_error_with_field(
@@ -36,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 (result != GRPC_ERROR_NONE) 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;
+    if (!GRPC_ERROR_IS_NONE(result)) return result;
   }
-#endif
   return GRPC_ERROR_NONE;
 }
 
@@ -64,7 +52,7 @@ void grpc_error_get_status(grpc_error_handle error,
                            grpc_http2_error_code* http_error,
                            const char** error_string) {
   // Fast path: We expect no error.
-  if (GPR_LIKELY(error == GRPC_ERROR_NONE)) {
+  if (GPR_LIKELY(GRPC_ERROR_IS_NONE(error))) {
     if (code != nullptr) *code = GRPC_STATUS_OK;
     if (message != nullptr) {
       // Normally, we call grpc_error_get_str(
@@ -87,7 +75,7 @@ void grpc_error_get_status(grpc_error_handle error,
   // until we find the first one that has a status code.
   grpc_error_handle found_error =
       recursively_find_error_with_field(error, GRPC_ERROR_INT_GRPC_STATUS);
-  if (found_error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(found_error)) {
     /// If no grpc-status exists, retry through the tree to find a http2 error
     /// code
     found_error =
@@ -96,7 +84,7 @@ void grpc_error_get_status(grpc_error_handle error,
 
   // If we found an error with a status code above, use that; otherwise,
   // fall back to using the parent error.
-  if (found_error == GRPC_ERROR_NONE) found_error = error;
+  if (GRPC_ERROR_IS_NONE(found_error)) found_error = error;
 
   grpc_status_code status = GRPC_STATUS_UNKNOWN;
   intptr_t integer;
@@ -107,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;
 
@@ -125,8 +111,8 @@ void grpc_error_get_status(grpc_error_handle error,
       *http_error =
           grpc_status_to_http2_error(static_cast<grpc_status_code>(integer));
     } else {
-      *http_error = found_error == GRPC_ERROR_NONE ? GRPC_HTTP2_NO_ERROR
-                                                   : GRPC_HTTP2_INTERNAL_ERROR;
+      *http_error = GRPC_ERROR_IS_NONE(found_error) ? GRPC_HTTP2_NO_ERROR
+                                                    : GRPC_HTTP2_INTERNAL_ERROR;
     }
   }
 
@@ -137,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
       }
     }
   }
@@ -173,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);
 }
 
@@ -100,9 +99,9 @@ bool HandshakeManager::CallNextHandshakerLocked(grpc_error_handle error) {
   // If we got an error or we've been shut down or we're exiting early or
   // we've finished the last handshaker, invoke the on_handshake_done
   // callback.  Otherwise, call the next handshaker.
-  if (error != GRPC_ERROR_NONE || is_shutdown_ || args_.exit_early ||
+  if (!GRPC_ERROR_IS_NONE(error) || is_shutdown_ || args_.exit_early ||
       index_ == handshakers_.size()) {
-    if (error == GRPC_ERROR_NONE && is_shutdown_) {
+    if (GRPC_ERROR_IS_NONE(error) && is_shutdown_) {
       error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("handshaker shutdown");
       // It is possible that the endpoint has already been destroyed by
       // a shutdown call while this callback was sitting on the ExecCtx
@@ -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;
@@ -165,14 +163,14 @@ void HandshakeManager::CallNextHandshakerFn(void* arg,
 
 void HandshakeManager::OnTimeoutFn(void* arg, grpc_error_handle error) {
   auto* mgr = static_cast<HandshakeManager*>(arg);
-  if (error == GRPC_ERROR_NONE) {  // Timer fired, rather than being cancelled
+  if (GRPC_ERROR_IS_NONE(error)) {  // Timer fired, rather than being cancelled
     mgr->Shutdown(GRPC_ERROR_CREATE_FROM_STATIC_STRING("Handshake timed out"));
   }
   mgr->Unref();
 }
 
 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,14 +118,13 @@ 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
 // callback with the error.
 void HttpConnectHandshaker::HandshakeFailedLocked(grpc_error_handle error) {
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     // If we were shut down after an endpoint operation succeeded but
     // before the endpoint callback was invoked, we need to generate our
     // own error.
@@ -164,7 +163,7 @@ void HttpConnectHandshaker::OnWriteDoneScheduler(void* arg,
 void HttpConnectHandshaker::OnWriteDone(void* arg, grpc_error_handle error) {
   auto* handshaker = static_cast<HttpConnectHandshaker*>(arg);
   ReleasableMutexLock lock(&handshaker->mu_);
-  if (error != GRPC_ERROR_NONE || handshaker->is_shutdown_) {
+  if (!GRPC_ERROR_IS_NONE(error) || handshaker->is_shutdown_) {
     // If the write failed or we're shutting down, clean up and invoke the
     // callback with the error.
     handshaker->HandshakeFailedLocked(GRPC_ERROR_REF(error));
@@ -198,7 +197,7 @@ void HttpConnectHandshaker::OnReadDoneScheduler(void* arg,
 void HttpConnectHandshaker::OnReadDone(void* arg, grpc_error_handle error) {
   auto* handshaker = static_cast<HttpConnectHandshaker*>(arg);
   ReleasableMutexLock lock(&handshaker->mu_);
-  if (error != GRPC_ERROR_NONE || handshaker->is_shutdown_) {
+  if (!GRPC_ERROR_IS_NONE(error) || handshaker->is_shutdown_) {
     // If the read failed or we're shutting down, clean up and invoke the
     // callback with the error.
     handshaker->HandshakeFailedLocked(GRPC_ERROR_REF(error));
@@ -211,7 +210,7 @@ void HttpConnectHandshaker::OnReadDone(void* arg, grpc_error_handle error) {
       error = grpc_http_parser_parse(&handshaker->http_parser_,
                                      handshaker->args_->read_buffer->slices[i],
                                      &body_start_offset);
-      if (error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(error)) {
         handshaker->HandshakeFailedLocked(error);
         goto done;
       }
@@ -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>());

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

@@ -284,4 +284,9 @@ const std::string& GrpcStatusContext::DisplayValue(const std::string& x) {
   return x;
 }
 
+std::string WaitForReady::DisplayValue(ValueType x) {
+  return absl::StrCat(x.value ? "true" : "false",
+                      x.explicitly_set ? " (explicit)" : "");
+}
+
 }  // namespace grpc_core

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

@@ -25,7 +25,6 @@
 
 #include <cstdint>
 #include <string>
-#include <type_traits>
 #include <utility>
 
 #include "absl/container/inlined_vector.h"
@@ -388,6 +387,17 @@ struct GrpcStatusContext {
   static const std::string& DisplayValue(const std::string& x);
 };
 
+// Annotation added by client surface code to denote wait-for-ready state
+struct WaitForReady {
+  struct ValueType {
+    bool value = false;
+    bool explicitly_set = false;
+  };
+  static absl::string_view DebugKey() { return "WaitForReady"; }
+  static constexpr bool kRepeatable = false;
+  static std::string DisplayValue(ValueType x);
+};
+
 namespace metadata_detail {
 
 // Build a key/value formatted debug string.
@@ -678,6 +688,10 @@ struct Value<Which, absl::enable_if_t<Which::kRepeatable == false &&
   void EncodeTo(Encoder* encoder) const {
     encoder->Encode(Which(), value);
   }
+  template <typename Encoder>
+  void VisitWith(Encoder* encoder) const {
+    return EncodeTo(encoder);
+  }
   void LogTo(LogFn log_fn) const {
     LogKeyValueTo(Which::key(), value, Which::Encode, log_fn);
   }
@@ -702,6 +716,10 @@ struct Value<Which, absl::enable_if_t<Which::kRepeatable == false &&
   }
   template <typename Encoder>
   void EncodeTo(Encoder*) const {}
+  template <typename Encoder>
+  void VisitWith(Encoder* encoder) const {
+    encoder->Encode(Which(), value);
+  }
   void LogTo(LogFn log_fn) const {
     LogKeyValueTo(Which::DebugKey(), value, Which::DisplayValue, log_fn);
   }
@@ -733,6 +751,10 @@ struct Value<Which, absl::enable_if_t<Which::kRepeatable == true &&
       encoder->Encode(Which(), v);
     }
   }
+  template <typename Encoder>
+  void VisitWith(Encoder* encoder) const {
+    return EncodeTo(encoder);
+  }
   void LogTo(LogFn log_fn) const {
     for (const auto& v : value) {
       LogKeyValueTo(Which::key(), v, Which::Encode, log_fn);
@@ -762,6 +784,12 @@ struct Value<Which, absl::enable_if_t<Which::kRepeatable == true &&
   }
   template <typename Encoder>
   void EncodeTo(Encoder*) const {}
+  template <typename Encoder>
+  void VisitWith(Encoder* encoder) const {
+    for (const auto& v : value) {
+      encoder->Encode(Which(), v);
+    }
+  }
   void LogTo(LogFn log_fn) const {
     for (const auto& v : value) {
       LogKeyValueTo(Which::DebugKey(), v, Which::DisplayValue, log_fn);
@@ -806,6 +834,17 @@ struct EncodeWrapper {
   }
 };
 
+// Callable for the table ForEach in ForEach() -- for each value, call the
+// appropriate visitor method.
+template <typename Encoder>
+struct ForEachWrapper {
+  Encoder* encoder;
+  template <typename Which>
+  void operator()(const Value<Which>& which) {
+    which.VisitWith(encoder);
+  }
+};
+
 // Callable for the ForEach in Log()
 struct LogWrapper {
   LogFn log_fn;
@@ -1003,10 +1042,7 @@ class MetadataMap {
   //    void Encode(TraitsType, typename TraitsType::ValueType value);
   // For fields for which we do not have traits, this will be a method
   // with the signature:
-  //    void Encode(grpc_mdelem md);
-  // TODO(ctiller): It's expected that the latter Encode method will
-  // become Encode(Slice, Slice) by the end of the current metadata API
-  // transitions.
+  //    void Encode(string_view key, Slice value);
   template <typename Encoder>
   void Encode(Encoder* encoder) const {
     table_.ForEach(metadata_detail::EncodeWrapper<Encoder>{encoder});
@@ -1015,6 +1051,15 @@ class MetadataMap {
     }
   }
 
+  // Like Encode, but also visit the non-encodable fields.
+  template <typename Encoder>
+  void ForEach(Encoder* encoder) const {
+    table_.ForEach(metadata_detail::ForEachWrapper<Encoder>{encoder});
+    for (const auto& unk : unknown_) {
+      encoder->Encode(unk.first, unk.second);
+    }
+  }
+
   // Similar to Encode, but targeted at logging: for each metadatum,
   // call f(key, value) as absl::string_views.
   void Log(metadata_detail::LogFn log_fn) const {
@@ -1227,7 +1272,7 @@ template <typename Derived, typename... Traits>
 Derived MetadataMap<Derived, Traits...>::Copy() const {
   Derived out(unknown_.arena());
   metadata_detail::CopySink<Derived> sink(&out);
-  Encode(&sink);
+  ForEach(&sink);
   return out;
 }
 
@@ -1254,7 +1299,7 @@ using grpc_metadata_batch_base = grpc_core::MetadataMap<
     grpc_core::LbCostBinMetadata, grpc_core::LbTokenMetadata,
     // Non-encodable things
     grpc_core::GrpcStreamNetworkState, grpc_core::PeerString,
-    grpc_core::GrpcStatusContext>;
+    grpc_core::GrpcStatusContext, grpc_core::WaitForReady>;
 
 struct grpc_metadata_batch : public grpc_metadata_batch_base {
   using grpc_metadata_batch_base::grpc_metadata_batch_base;

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

@@ -21,7 +21,6 @@
 
 #include <cstdint>
 #include <string>
-#include <type_traits>
 #include <utility>
 
 #include "absl/functional/function_ref.h"

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

@@ -25,8 +25,9 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/memory/memory.h"
 #include "absl/status/statusor.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/support/alloc.h>
 #include <grpc/support/log.h>
@@ -34,7 +35,6 @@
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -129,25 +129,20 @@ void TCPConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
   }
   GPR_ASSERT(args->endpoint == nullptr);
   args_ = args;
-  char* address = grpc_channel_args_find_string(
-      args->args, GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS);
-  absl::StatusOr<URI> uri = URI::Parse(address);
+  absl::StatusOr<URI> uri = URI::Parse(
+      args->args.GetString(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS).value());
   if (!uri.ok() || !grpc_parse_uri(*uri, &addr_)) {
     MutexLock lock(&mu_);
     FinishLocked(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "Resolved address in invalid format"));
     return;
   }
-  bind_endpoint_to_pollset_ = grpc_channel_args_find_bool(
-      args->args, GRPC_ARG_TCP_HANDSHAKER_BIND_ENDPOINT_TO_POLLSET, false);
-  const char* args_to_remove[] = {
-      GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS,
-      GRPC_ARG_TCP_HANDSHAKER_BIND_ENDPOINT_TO_POLLSET};
+  bind_endpoint_to_pollset_ =
+      args->args.GetBool(GRPC_ARG_TCP_HANDSHAKER_BIND_ENDPOINT_TO_POLLSET)
+          .value_or(false);
   // Update args to not contain the args relevant to TCP connect handshaker.
-  grpc_channel_args* channel_args = grpc_channel_args_copy_and_remove(
-      args->args, args_to_remove, GPR_ARRAY_SIZE(args_to_remove));
-  grpc_channel_args_destroy(args->args);
-  args->args = channel_args;
+  args->args = args->args.Remove(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS)
+                   .Remove(GRPC_ARG_TCP_HANDSHAKER_BIND_ENDPOINT_TO_POLLSET);
   // In some implementations, the closure can be flushed before
   // grpc_tcp_client_connect() returns, and since the closure requires access
   // to mu_, this can result in a deadlock (see
@@ -160,7 +155,7 @@ void TCPConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
   // Instead pass endpoint_ and swap this endpoint to
   // args endpoint on success.
   grpc_tcp_client_connect(&connected_, &endpoint_to_destroy_,
-                          interested_parties_, args->args, &addr_,
+                          interested_parties_, args->args.ToC().get(), &addr_,
                           args->deadline);
 }
 
@@ -169,8 +164,8 @@ void TCPConnectHandshaker::Connected(void* arg, grpc_error_handle error) {
       static_cast<TCPConnectHandshaker*>(arg));
   {
     MutexLock lock(&self->mu_);
-    if (error != GRPC_ERROR_NONE || self->shutdown_) {
-      if (error == GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error) || self->shutdown_) {
+      if (GRPC_ERROR_IS_NONE(error)) {
         error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("tcp handshaker shutdown");
       } else {
         error = GRPC_ERROR_REF(error);
@@ -215,8 +210,7 @@ TCPConnectHandshaker::~TCPConnectHandshaker() {
 void TCPConnectHandshaker::CleanupArgsForFailureLocked() {
   read_buffer_to_destroy_ = args_->read_buffer;
   args_->read_buffer = nullptr;
-  grpc_channel_args_destroy(args_->args);
-  args_->args = nullptr;
+  args_->args = ChannelArgs();
 }
 
 void TCPConnectHandshaker::FinishLocked(grpc_error_handle error) {
@@ -233,7 +227,7 @@ void TCPConnectHandshaker::FinishLocked(grpc_error_handle error) {
 
 class TCPConnectHandshakerFactory : 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(

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

@@ -161,9 +161,6 @@ void grpc_transport_stream_op_batch_finish_with_failure(
 void grpc_transport_stream_op_batch_queue_finish_with_failure(
     grpc_transport_stream_op_batch* batch, grpc_error_handle error,
     grpc_core::CallCombinerClosureList* closures) {
-  if (batch->send_message) {
-    batch->payload->send_message.send_message.reset();
-  }
   if (batch->cancel_stream) {
     GRPC_ERROR_UNREF(batch->payload->cancel_stream.cancel_error);
   }