grpc 1.41.0 → 1.43.1

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

@@ -22,6 +22,7 @@
 
 #include <grpc/support/string_util.h>
 
+#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/error_internal.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/transport/status_conversion.h"
@@ -33,7 +34,14 @@ static grpc_error_handle recursively_find_error_with_field(
   if (grpc_error_get_int(error, which, &unused)) {
     return error;
   }
-  if (grpc_error_is_special(error)) return nullptr;
+#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) {
@@ -44,26 +52,27 @@ static grpc_error_handle recursively_find_error_with_field(
     if (result) return result;
     slot = lerr->next;
   }
-  return nullptr;
+#endif
+  return GRPC_ERROR_NONE;
 }
 
 void grpc_error_get_status(grpc_error_handle error, grpc_millis deadline,
-                           grpc_status_code* code, grpc_slice* slice,
+                           grpc_status_code* code, std::string* message,
                            grpc_http2_error_code* http_error,
                            const char** error_string) {
   // Fast path: We expect no error.
   if (GPR_LIKELY(error == GRPC_ERROR_NONE)) {
     if (code != nullptr) *code = GRPC_STATUS_OK;
-    if (slice != nullptr) {
+    if (message != nullptr) {
       // Normally, we call grpc_error_get_str(
-      //   error, GRPC_ERROR_STR_GRPC_MESSAGE, slice).
+      //   error, GRPC_ERROR_STR_GRPC_MESSAGE, message).
       // We can fastpath since we know that:
       // 1) Error is null
       // 2) which == GRPC_ERROR_STR_GRPC_MESSAGE
-      // 3) The resulting slice is statically known.
-      // 4) Said resulting slice is of length 0 ("").
+      // 3) The resulting message is statically known.
+      // 4) Said resulting message is "".
       // This means 3 movs, instead of 10s of instructions and a strlen.
-      *slice = grpc_core::ExternallyManagedSlice("");
+      *message = "";
     }
     if (http_error != nullptr) {
       *http_error = GRPC_HTTP2_NO_ERROR;
@@ -94,6 +103,10 @@ void grpc_error_get_status(grpc_error_handle error, grpc_millis deadline,
                                 &integer)) {
     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;
 
@@ -116,10 +129,16 @@ void grpc_error_get_status(grpc_error_handle error, grpc_millis deadline,
 
   // If the error has a status message, use it.  Otherwise, fall back to
   // the error description.
-  if (slice != nullptr) {
-    if (!grpc_error_get_str(found_error, GRPC_ERROR_STR_GRPC_MESSAGE, slice)) {
-      if (!grpc_error_get_str(found_error, GRPC_ERROR_STR_DESCRIPTION, slice)) {
-        *slice = grpc_slice_from_static_string("unknown error");
+  if (message != nullptr) {
+    if (!grpc_error_get_str(found_error, GRPC_ERROR_STR_GRPC_MESSAGE,
+                            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
       }
     }
   }
@@ -129,13 +148,10 @@ absl::Status grpc_error_to_absl_status(grpc_error_handle error) {
   grpc_status_code status;
   // TODO(yashykt): This should be updated once we decide on how to use the
   // absl::Status payload to capture all the contents of grpc_error.
-  grpc_slice message;
+  std::string message;
   grpc_error_get_status(error, GRPC_MILLIS_INF_FUTURE, &status, &message,
                         nullptr /* http_error */, nullptr /* error_string */);
-  return absl::Status(static_cast<absl::StatusCode>(status),
-                      absl::string_view(reinterpret_cast<const char*>(
-                                            GRPC_SLICE_START_PTR(message)),
-                                        GRPC_SLICE_LENGTH(message)));
+  return absl::Status(static_cast<absl::StatusCode>(status), message);
 }
 
 grpc_error_handle absl_status_to_grpc_error(absl::Status status) {
@@ -153,6 +169,14 @@ 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 =
@@ -162,5 +186,6 @@ bool grpc_error_has_clear_grpc_status(grpc_error_handle error) {
     }
     slot = lerr->next;
   }
+#endif
   return false;
 }

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

@@ -35,7 +35,7 @@
 /// msg, http_status, error_string) are unneeded, they can be passed as
 /// NULL.
 void grpc_error_get_status(grpc_error_handle error, grpc_millis deadline,
-                           grpc_status_code* code, grpc_slice* slice,
+                           grpc_status_code* code, std::string* message,
                            grpc_http2_error_code* http_error,
                            const char** error_string);
 

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

@@ -279,9 +279,9 @@ void grpc_mdctx_global_shutdown() {
 #ifndef NDEBUG
 static int is_mdelem_static(grpc_mdelem e) {
   return reinterpret_cast<grpc_core::StaticMetadata*>(GRPC_MDELEM_DATA(e)) >=
-             &grpc_static_mdelem_table()[0] &&
+             &grpc_core::g_static_mdelem_table[0] &&
          reinterpret_cast<grpc_core::StaticMetadata*>(GRPC_MDELEM_DATA(e)) <
-             &grpc_static_mdelem_table()[GRPC_STATIC_MDELEM_COUNT];
+             &grpc_core::g_static_mdelem_table[GRPC_STATIC_MDELEM_COUNT];
 }
 #endif
 
@@ -549,14 +549,35 @@ grpc_mdelem grpc_mdelem_from_slices(
 }
 
 grpc_mdelem grpc_mdelem_from_grpc_metadata(grpc_metadata* metadata) {
-  bool changed = false;
+  bool key_changed = false;
   grpc_slice key_slice =
-      grpc_slice_maybe_static_intern(metadata->key, &changed);
+      grpc_slice_maybe_static_intern(metadata->key, &key_changed);
+  bool value_changed = false;
+  grpc_slice* unref_slice = nullptr;
   grpc_slice value_slice =
-      grpc_slice_maybe_static_intern(metadata->value, &changed);
-  return grpc_mdelem_create(
-      key_slice, value_slice,
-      changed ? nullptr : reinterpret_cast<grpc_mdelem_data*>(metadata));
+      grpc_slice_maybe_static_intern(metadata->value, &value_changed);
+  // If key or value changed, but the other didn't.... AND the other is a NOP
+  // refcount, then we need to convert it to a slice with a refcount else we run
+  // the risk of leaving a dangling reference to that metadata on the heap via
+  // this mdelem.
+  if (key_changed && !value_changed && value_slice.refcount != nullptr &&
+      value_slice.refcount->GetType() == grpc_slice_refcount::Type::NOP) {
+    value_slice = grpc_slice_copy(value_slice);
+    unref_slice = &value_slice;
+    value_changed = true;
+  } else if (!key_changed && value_changed && key_slice.refcount != nullptr &&
+             key_slice.refcount->GetType() == grpc_slice_refcount::Type::NOP) {
+    key_slice = grpc_slice_copy(key_slice);
+    unref_slice = &key_slice;
+    key_changed = true;
+  }
+  auto mdelem =
+      grpc_mdelem_create(key_slice, value_slice,
+                         key_changed || value_changed
+                             ? nullptr
+                             : reinterpret_cast<grpc_mdelem_data*>(metadata));
+  if (unref_slice != nullptr) grpc_slice_unref_internal(*unref_slice);
+  return mdelem;
 }
 
 static void* get_user_data(UserData* user_data, void (*destroy_func)(void*)) {
@@ -577,7 +598,7 @@ void* grpc_mdelem_get_user_data(grpc_mdelem md, void (*destroy_func)(void*)) {
           grpc_static_mdelem_user_data
               [reinterpret_cast<grpc_core::StaticMetadata*>(
                    GRPC_MDELEM_DATA(md)) -
-               grpc_static_mdelem_table()]);
+               grpc_core::g_static_mdelem_table]);
     case GRPC_MDELEM_STORAGE_ALLOCATED: {
       auto* am = reinterpret_cast<AllocatedMetadata*>(GRPC_MDELEM_DATA(md));
       return get_user_data(am->user_data(), destroy_func);
@@ -619,7 +640,7 @@ void* grpc_mdelem_set_user_data(grpc_mdelem md, void (*destroy_func)(void*),
           grpc_static_mdelem_user_data
               [reinterpret_cast<grpc_core::StaticMetadata*>(
                    GRPC_MDELEM_DATA(md)) -
-               grpc_static_mdelem_table()]);
+               grpc_core::g_static_mdelem_table]);
     case GRPC_MDELEM_STORAGE_ALLOCATED: {
       auto* am = reinterpret_cast<AllocatedMetadata*>(GRPC_MDELEM_DATA(md));
       return set_user_data(am->user_data(), destroy_func, data);

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

@@ -313,10 +313,10 @@ class AllocatedMetadata : public RefcountedMdBase {
   // TODO(arjunroy): Change to use strongly typed slices instead.
   struct NoRefKey {};
   AllocatedMetadata(const grpc_slice& key, const grpc_slice& value);
-  AllocatedMetadata(const grpc_core::ManagedMemorySlice& key,
-                    const grpc_core::UnmanagedMemorySlice& value);
-  AllocatedMetadata(const grpc_core::ExternallyManagedSlice& key,
-                    const grpc_core::UnmanagedMemorySlice& value);
+  AllocatedMetadata(const ManagedMemorySlice& key,
+                    const UnmanagedMemorySlice& value);
+  AllocatedMetadata(const ExternallyManagedSlice& key,
+                    const UnmanagedMemorySlice& value);
   AllocatedMetadata(const grpc_slice& key, const grpc_slice& value,
                     const NoRefKey*);
   ~AllocatedMetadata();
@@ -409,7 +409,8 @@ inline void grpc_mdelem_unref(grpc_mdelem gmd) {
   (GRPC_SLICE_LENGTH(GRPC_MDKEY((e))) + GRPC_SLICE_LENGTH(GRPC_MDVALUE((e))) + \
    32)
 
-#define GRPC_MDSTR_KV_HASH(k_hash, v_hash) (GPR_ROTL((k_hash), 2) ^ (v_hash))
+#define GRPC_MDSTR_KV_HASH(k_hash, v_hash) \
+  (::grpc_core::RotateLeft(size_t(k_hash), size_t(2)) ^ (v_hash))
 
 void grpc_mdctx_global_init(void);
 void grpc_mdctx_global_shutdown();

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

@@ -24,7 +24,6 @@
 #include <string.h>
 
 #include "absl/container/inlined_vector.h"
-#include "absl/strings/str_join.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -33,264 +32,6 @@
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 
-static void assert_valid_list(grpc_mdelem_list* list) {
-#ifndef NDEBUG
-  grpc_linked_mdelem* l;
-
-  GPR_ASSERT((list->head == nullptr) == (list->tail == nullptr));
-  if (!list->head) return;
-  GPR_ASSERT(list->head->prev == nullptr);
-  GPR_ASSERT(list->tail->next == nullptr);
-  GPR_ASSERT((list->head == list->tail) == (list->head->next == nullptr));
-
-  size_t verified_count = 0;
-  for (l = list->head; l; l = l->next) {
-    GPR_ASSERT(!GRPC_MDISNULL(l->md));
-    GPR_ASSERT((l->prev == nullptr) == (l == list->head));
-    GPR_ASSERT((l->next == nullptr) == (l == list->tail));
-    if (l->next) GPR_ASSERT(l->next->prev == l);
-    if (l->prev) GPR_ASSERT(l->prev->next == l);
-    verified_count++;
-  }
-  GPR_ASSERT(list->count == verified_count);
-#else
-  // Avoid unused-parameter warning for debug-only parameter
-  (void)list;
-#endif /* NDEBUG */
-}
-
-static void assert_valid_callouts(grpc_metadata_batch* batch) {
-#ifndef NDEBUG
-  for (grpc_linked_mdelem* l = batch->list.head; l != nullptr; l = l->next) {
-    grpc_slice key_interned = grpc_slice_intern(GRPC_MDKEY(l->md));
-    grpc_metadata_batch_callouts_index callout_idx =
-        GRPC_BATCH_INDEX_OF(key_interned);
-    if (callout_idx != GRPC_BATCH_CALLOUTS_COUNT) {
-      GPR_ASSERT(batch->idx.array[callout_idx] == l);
-    }
-    grpc_slice_unref_internal(key_interned);
-  }
-#else
-  // Avoid unused-parameter warning for debug-only parameter
-  (void)batch;
-#endif
-}
-
-#ifndef NDEBUG
-void grpc_metadata_batch_assert_ok(grpc_metadata_batch* batch) {
-  assert_valid_list(&batch->list);
-}
-#endif /* NDEBUG */
-
-void grpc_metadata_batch_init(grpc_metadata_batch* batch) {
-  memset(batch, 0, sizeof(*batch));
-  batch->deadline = GRPC_MILLIS_INF_FUTURE;
-}
-
-void grpc_metadata_batch_destroy(grpc_metadata_batch* batch) {
-  grpc_linked_mdelem* l;
-  for (l = batch->list.head; l; l = l->next) {
-    GRPC_MDELEM_UNREF(l->md);
-  }
-}
-
-grpc_error_handle grpc_attach_md_to_error(grpc_error_handle src,
-                                          grpc_mdelem md) {
-  grpc_error_handle out = grpc_error_set_str(
-      grpc_error_set_str(src, GRPC_ERROR_STR_KEY,
-                         grpc_slice_ref_internal(GRPC_MDKEY(md))),
-      GRPC_ERROR_STR_VALUE, grpc_slice_ref_internal(GRPC_MDVALUE(md)));
-  return out;
-}
-
-static grpc_error_handle GPR_ATTRIBUTE_NOINLINE error_with_md(grpc_mdelem md) {
-  return grpc_attach_md_to_error(
-      GRPC_ERROR_CREATE_FROM_STATIC_STRING("Unallowed duplicate metadata"), md);
-}
-
-static grpc_error_handle link_callout(grpc_metadata_batch* batch,
-                                      grpc_linked_mdelem* storage,
-                                      grpc_metadata_batch_callouts_index idx) {
-  GPR_DEBUG_ASSERT(idx >= 0 && idx < GRPC_BATCH_CALLOUTS_COUNT);
-  if (GPR_LIKELY(batch->idx.array[idx] == nullptr)) {
-    ++batch->list.default_count;
-    batch->idx.array[idx] = storage;
-    return GRPC_ERROR_NONE;
-  }
-  return error_with_md(storage->md);
-}
-
-static grpc_error_handle maybe_link_callout(grpc_metadata_batch* batch,
-                                            grpc_linked_mdelem* storage)
-    GRPC_MUST_USE_RESULT;
-
-static grpc_error_handle maybe_link_callout(grpc_metadata_batch* batch,
-                                            grpc_linked_mdelem* storage) {
-  grpc_metadata_batch_callouts_index idx =
-      GRPC_BATCH_INDEX_OF(GRPC_MDKEY(storage->md));
-  if (idx == GRPC_BATCH_CALLOUTS_COUNT) {
-    return GRPC_ERROR_NONE;
-  }
-  return link_callout(batch, storage, idx);
-}
-
-static void maybe_unlink_callout(grpc_metadata_batch* batch,
-                                 grpc_linked_mdelem* storage) {
-  grpc_metadata_batch_callouts_index idx =
-      GRPC_BATCH_INDEX_OF(GRPC_MDKEY(storage->md));
-  if (idx == GRPC_BATCH_CALLOUTS_COUNT) {
-    return;
-  }
-  --batch->list.default_count;
-  GPR_DEBUG_ASSERT(batch->idx.array[idx] != nullptr);
-  batch->idx.array[idx] = nullptr;
-}
-
-grpc_error_handle grpc_metadata_batch_add_head(grpc_metadata_batch* batch,
-                                               grpc_linked_mdelem* storage,
-                                               grpc_mdelem elem_to_add) {
-  GPR_DEBUG_ASSERT(!GRPC_MDISNULL(elem_to_add));
-  storage->md = elem_to_add;
-  return grpc_metadata_batch_link_head(batch, storage);
-}
-
-static void link_head(grpc_mdelem_list* list, grpc_linked_mdelem* storage) {
-  assert_valid_list(list);
-  GPR_DEBUG_ASSERT(!GRPC_MDISNULL(storage->md));
-  storage->prev = nullptr;
-  storage->next = list->head;
-  storage->reserved = nullptr;
-  if (list->head != nullptr) {
-    list->head->prev = storage;
-  } else {
-    list->tail = storage;
-  }
-  list->head = storage;
-  list->count++;
-  assert_valid_list(list);
-}
-
-grpc_error_handle grpc_metadata_batch_link_head(grpc_metadata_batch* batch,
-                                                grpc_linked_mdelem* storage) {
-  assert_valid_callouts(batch);
-  grpc_error_handle err = maybe_link_callout(batch, storage);
-  if (err != GRPC_ERROR_NONE) {
-    assert_valid_callouts(batch);
-    return err;
-  }
-  link_head(&batch->list, storage);
-  assert_valid_callouts(batch);
-  return GRPC_ERROR_NONE;
-}
-
-// TODO(arjunroy): Need to revisit this and see what guarantees exist between
-// C-core and the internal-metadata subsystem. E.g. can we ensure a particular
-// metadata is never added twice, even in the presence of user supplied data?
-grpc_error_handle grpc_metadata_batch_link_head(
-    grpc_metadata_batch* batch, grpc_linked_mdelem* storage,
-    grpc_metadata_batch_callouts_index idx) {
-  GPR_DEBUG_ASSERT(GRPC_BATCH_INDEX_OF(GRPC_MDKEY(storage->md)) == idx);
-  assert_valid_callouts(batch);
-  grpc_error_handle err = link_callout(batch, storage, idx);
-  if (GPR_UNLIKELY(err != GRPC_ERROR_NONE)) {
-    assert_valid_callouts(batch);
-    return err;
-  }
-  link_head(&batch->list, storage);
-  assert_valid_callouts(batch);
-  return GRPC_ERROR_NONE;
-}
-
-grpc_error_handle grpc_metadata_batch_add_tail(grpc_metadata_batch* batch,
-                                               grpc_linked_mdelem* storage,
-                                               grpc_mdelem elem_to_add) {
-  GPR_DEBUG_ASSERT(!GRPC_MDISNULL(elem_to_add));
-  storage->md = elem_to_add;
-  return grpc_metadata_batch_link_tail(batch, storage);
-}
-
-static void link_tail(grpc_mdelem_list* list, grpc_linked_mdelem* storage) {
-  assert_valid_list(list);
-  GPR_DEBUG_ASSERT(!GRPC_MDISNULL(storage->md));
-  storage->prev = list->tail;
-  storage->next = nullptr;
-  storage->reserved = nullptr;
-  if (list->tail != nullptr) {
-    list->tail->next = storage;
-  } else {
-    list->head = storage;
-  }
-  list->tail = storage;
-  list->count++;
-  assert_valid_list(list);
-}
-
-grpc_error_handle grpc_metadata_batch_link_tail(grpc_metadata_batch* batch,
-                                                grpc_linked_mdelem* storage) {
-  assert_valid_callouts(batch);
-  grpc_error_handle err = maybe_link_callout(batch, storage);
-  if (err != GRPC_ERROR_NONE) {
-    assert_valid_callouts(batch);
-    return err;
-  }
-  link_tail(&batch->list, storage);
-  assert_valid_callouts(batch);
-  return GRPC_ERROR_NONE;
-}
-
-grpc_error_handle grpc_metadata_batch_link_tail(
-    grpc_metadata_batch* batch, grpc_linked_mdelem* storage,
-    grpc_metadata_batch_callouts_index idx) {
-  GPR_DEBUG_ASSERT(GRPC_BATCH_INDEX_OF(GRPC_MDKEY(storage->md)) == idx);
-  assert_valid_callouts(batch);
-  grpc_error_handle err = link_callout(batch, storage, idx);
-  if (GPR_UNLIKELY(err != GRPC_ERROR_NONE)) {
-    assert_valid_callouts(batch);
-    return err;
-  }
-  link_tail(&batch->list, storage);
-  assert_valid_callouts(batch);
-  return GRPC_ERROR_NONE;
-}
-
-static void unlink_storage(grpc_mdelem_list* list,
-                           grpc_linked_mdelem* storage) {
-  assert_valid_list(list);
-  if (storage->prev != nullptr) {
-    storage->prev->next = storage->next;
-  } else {
-    list->head = storage->next;
-  }
-  if (storage->next != nullptr) {
-    storage->next->prev = storage->prev;
-  } else {
-    list->tail = storage->prev;
-  }
-  list->count--;
-  assert_valid_list(list);
-}
-
-void grpc_metadata_batch_remove(grpc_metadata_batch* batch,
-                                grpc_linked_mdelem* storage) {
-  assert_valid_callouts(batch);
-  maybe_unlink_callout(batch, storage);
-  unlink_storage(&batch->list, storage);
-  GRPC_MDELEM_UNREF(storage->md);
-  assert_valid_callouts(batch);
-}
-
-void grpc_metadata_batch_remove(grpc_metadata_batch* batch,
-                                grpc_metadata_batch_callouts_index idx) {
-  assert_valid_callouts(batch);
-  grpc_linked_mdelem* storage = batch->idx.array[idx];
-  GPR_DEBUG_ASSERT(storage != nullptr);
-  --batch->list.default_count;
-  batch->idx.array[idx] = nullptr;
-  unlink_storage(&batch->list, storage);
-  GRPC_MDELEM_UNREF(storage->md);
-  assert_valid_callouts(batch);
-}
-
 void grpc_metadata_batch_set_value(grpc_linked_mdelem* storage,
                                    const grpc_slice& value) {
   grpc_mdelem old_mdelem = storage->md;
@@ -300,131 +41,59 @@ void grpc_metadata_batch_set_value(grpc_linked_mdelem* storage,
   GRPC_MDELEM_UNREF(old_mdelem);
 }
 
-absl::optional<absl::string_view> grpc_metadata_batch_get_value(
-    grpc_metadata_batch* batch, absl::string_view target_key,
-    std::string* concatenated_value) {
-  // Find all values for the specified key.
-  GPR_DEBUG_ASSERT(batch != nullptr);
-  absl::InlinedVector<absl::string_view, 1> values;
-  for (grpc_linked_mdelem* md = batch->list.head; md != nullptr;
-       md = md->next) {
-    absl::string_view key = grpc_core::StringViewFromSlice(GRPC_MDKEY(md->md));
-    absl::string_view value =
-        grpc_core::StringViewFromSlice(GRPC_MDVALUE(md->md));
-    if (target_key == key) values.push_back(value);
-  }
-  // If none found, no match.
-  if (values.empty()) return absl::nullopt;
-  // If exactly one found, return it as-is.
-  if (values.size() == 1) return values.front();
-  // If more than one found, concatenate the values, using
-  // *concatenated_values as a temporary holding place for the
-  // concatenated string.
-  *concatenated_value = absl::StrJoin(values, ",");
-  return *concatenated_value;
-}
-
-grpc_error_handle grpc_metadata_batch_substitute(grpc_metadata_batch* batch,
-                                                 grpc_linked_mdelem* storage,
-                                                 grpc_mdelem new_mdelem) {
-  assert_valid_callouts(batch);
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  grpc_mdelem old_mdelem = storage->md;
-  if (!grpc_slice_eq(GRPC_MDKEY(new_mdelem), GRPC_MDKEY(old_mdelem))) {
-    maybe_unlink_callout(batch, storage);
-    storage->md = new_mdelem;
-    error = maybe_link_callout(batch, storage);
-    if (error != GRPC_ERROR_NONE) {
-      unlink_storage(&batch->list, storage);
-      GRPC_MDELEM_UNREF(storage->md);
-    }
-  } else {
-    storage->md = new_mdelem;
-  }
-  GRPC_MDELEM_UNREF(old_mdelem);
-  assert_valid_callouts(batch);
-  return error;
-}
-
-void grpc_metadata_batch_clear(grpc_metadata_batch* batch) {
-  grpc_metadata_batch_destroy(batch);
-  grpc_metadata_batch_init(batch);
-}
-
-bool grpc_metadata_batch_is_empty(grpc_metadata_batch* batch) {
-  return batch->list.head == nullptr &&
-         batch->deadline == GRPC_MILLIS_INF_FUTURE;
-}
+namespace {
 
-size_t grpc_metadata_batch_size(grpc_metadata_batch* batch) {
-  size_t size = 0;
-  for (grpc_linked_mdelem* elem = batch->list.head; elem != nullptr;
-       elem = elem->next) {
-    size += GRPC_MDELEM_LENGTH(elem->md);
-  }
-  return size;
-}
-
-static void add_error(grpc_error_handle* composite, grpc_error_handle error,
-                      const char* composite_error_string) {
-  if (error == GRPC_ERROR_NONE) return;
-  if (*composite == GRPC_ERROR_NONE) {
-    *composite = GRPC_ERROR_CREATE_FROM_COPIED_STRING(composite_error_string);
-  }
-  *composite = grpc_error_add_child(*composite, error);
-}
+class CopySink {
+ public:
+  explicit CopySink(grpc_metadata_batch* dst) : dst_(dst) {}
 
-grpc_error_handle grpc_metadata_batch_filter(
-    grpc_metadata_batch* batch, grpc_metadata_batch_filter_func func,
-    void* user_data, const char* composite_error_string) {
-  grpc_linked_mdelem* l = batch->list.head;
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  while (l) {
-    grpc_linked_mdelem* next = l->next;
-    grpc_filtered_mdelem new_mdelem = func(user_data, l->md);
-    add_error(&error, new_mdelem.error, composite_error_string);
-    if (GRPC_MDISNULL(new_mdelem.md)) {
-      grpc_metadata_batch_remove(batch, l);
-    } else if (new_mdelem.md.payload != l->md.payload) {
-      grpc_metadata_batch_substitute(batch, l, new_mdelem.md);
-    }
-    l = next;
-  }
-  return error;
-}
-
-void grpc_metadata_batch_copy(grpc_metadata_batch* src,
-                              grpc_metadata_batch* dst,
-                              grpc_linked_mdelem* storage) {
-  grpc_metadata_batch_init(dst);
-  dst->deadline = src->deadline;
-  size_t i = 0;
-  for (grpc_linked_mdelem* elem = src->list.head; elem != nullptr;
-       elem = elem->next) {
+  void Encode(grpc_mdelem md) {
     // If the mdelem is not external, take a ref.
     // Otherwise, create a new copy, holding its own refs to the
     // underlying slices.
-    grpc_mdelem md;
-    if (GRPC_MDELEM_STORAGE(elem->md) != GRPC_MDELEM_STORAGE_EXTERNAL) {
-      md = GRPC_MDELEM_REF(elem->md);
+    if (GRPC_MDELEM_STORAGE(md) != GRPC_MDELEM_STORAGE_EXTERNAL) {
+      md = GRPC_MDELEM_REF(md);
     } else {
-      md = grpc_mdelem_from_slices(
-          grpc_slice_ref_internal(GRPC_MDKEY(elem->md)),
-          grpc_slice_ref_internal(GRPC_MDVALUE(elem->md)));
+      md = grpc_mdelem_from_slices(grpc_slice_copy(GRPC_MDKEY(md)),
+                                   grpc_slice_copy(GRPC_MDVALUE(md)));
     }
     // Error unused in non-debug builds.
-    grpc_error_handle GRPC_UNUSED error =
-        grpc_metadata_batch_add_tail(dst, &storage[i++], md);
-    // The only way that grpc_metadata_batch_add_tail() can fail is if
+    grpc_error_handle GRPC_UNUSED error = dst_->Append(md);
+    // The only way that Append() can fail is if
     // there's a duplicate entry for a callout.  However, that can't be
     // the case here, because we would not have been allowed to create
     // a source batch that had that kind of conflict.
     GPR_DEBUG_ASSERT(error == GRPC_ERROR_NONE);
   }
-}
 
-void grpc_metadata_batch_move(grpc_metadata_batch* src,
+  template <class T, class V>
+  void Encode(T trait, V value) {
+    dst_->Set(trait, value);
+  }
+
+  template <class T>
+  void Encode(T trait, const grpc_core::Slice& value) {
+    dst_->Set(trait, std::move(value.AsOwned()));
+  }
+
+ private:
+  grpc_metadata_batch* dst_;
+};
+
+}  // namespace
+
+void grpc_metadata_batch_copy(const grpc_metadata_batch* src,
                               grpc_metadata_batch* dst) {
-  *dst = *src;
-  grpc_metadata_batch_init(src);
+  dst->Clear();
+  CopySink sink(dst);
+  src->Encode(&sink);
+}
+
+grpc_error_handle grpc_attach_md_to_error(grpc_error_handle src,
+                                          grpc_mdelem md) {
+  grpc_error_handle out = grpc_error_set_str(
+      grpc_error_set_str(src, GRPC_ERROR_STR_KEY,
+                         grpc_core::StringViewFromSlice(GRPC_MDKEY(md))),
+      GRPC_ERROR_STR_VALUE, grpc_core::StringViewFromSlice(GRPC_MDVALUE(md)));
+  return out;
 }