Metadata: replace usage of grpc_metadata_batch_link_{head,tail} with Link{Head,Tail} method (#27419)

* Metadata: replace usage of grpc_metadata_batch_link_{head,tail} with Link{Head,Tail} method

* Automated change: Fix sanity tests

Co-authored-by: ctiller <ctiller@users.noreply.github.com>

src/core/ext/filters/client_channel/client_channel.cc

@@ -2490,8 +2490,7 @@ class ClientChannel::LoadBalancedCall::Metadata
     linked_mdelem->md = grpc_mdelem_from_slices(
         ExternallyManagedSlice(key.data(), key.size()),
         ExternallyManagedSlice(value.data(), value.size()));
-    GPR_ASSERT(grpc_metadata_batch_link_tail(batch_, linked_mdelem) ==
-               GRPC_ERROR_NONE);
+    GPR_ASSERT(batch_->LinkTail(linked_mdelem) == GRPC_ERROR_NONE);
   }
 
   std::vector<std::pair<std::string, std::string>> TestOnlyCopyToVector()

src/core/ext/transport/binder/transport/binder_transport.cc

@@ -132,7 +132,7 @@ static void AssignMetadata(grpc_metadata_batch* mb, grpc_core::Arena* arena,
     // Unref here to prevent memory leak
     grpc_slice_unref_internal(key);
     grpc_slice_unref_internal(value);
-    GPR_ASSERT(grpc_metadata_batch_link_tail(mb, glm) == GRPC_ERROR_NONE);
+    GPR_ASSERT(mb->LinkTail(glm) == GRPC_ERROR_NONE);
   }
 }
 
@@ -302,8 +302,8 @@ static void recv_trailing_metadata_locked(void* arg,
         grpc_linked_mdelem* glm = static_cast<grpc_linked_mdelem*>(
             gbs->arena->Alloc(sizeof(grpc_linked_mdelem)));
         glm->md = grpc_get_reffed_status_elem(args->status);
-        GPR_ASSERT(grpc_metadata_batch_link_tail(gbs->recv_trailing_metadata,
-                                                 glm) == GRPC_ERROR_NONE);
+        GPR_ASSERT(gbs->recv_trailing_metadata->LinkTail(glm) ==
+                   GRPC_ERROR_NONE);
         gpr_log(GPR_INFO, "trailing_metadata = %p",
                 gbs->recv_trailing_metadata);
         gpr_log(GPR_INFO, "glm = %p", glm);

src/core/ext/transport/chttp2/transport/incoming_metadata.cc

@@ -39,7 +39,7 @@ grpc_error_handle grpc_chttp2_incoming_metadata_buffer_add(
         buffer->arena->Alloc(sizeof(grpc_linked_mdelem)));
   }
   storage->md = elem;
-  return grpc_metadata_batch_link_tail(&buffer->batch, storage);
+  return buffer->batch.LinkTail(storage);
 }
 
 grpc_error_handle grpc_chttp2_incoming_metadata_buffer_replace_or_add(

src/core/ext/transport/inproc/inproc_transport.cc

@@ -312,7 +312,7 @@ grpc_error_handle fill_in_metadata(inproc_stream* s,
     nelem->md = grpc_mdelem_from_slices(grpc_slice_intern(GRPC_MDKEY(md)),
                                         grpc_slice_intern(GRPC_MDVALUE(md)));
 
-    error = grpc_metadata_batch_link_tail(out_md, nelem);
+    error = out_md->LinkTail(nelem);
   });
   return error;
 }
@@ -433,13 +433,11 @@ void fail_helper_locked(inproc_stream* s, grpc_error_handle error) {
       grpc_linked_mdelem* path_md =
           static_cast<grpc_linked_mdelem*>(s->arena->Alloc(sizeof(*path_md)));
       path_md->md = grpc_mdelem_from_slices(g_fake_path_key, g_fake_path_value);
-      GPR_ASSERT(grpc_metadata_batch_link_tail(&fake_md, path_md) ==
-                 GRPC_ERROR_NONE);
+      GPR_ASSERT(fake_md.LinkTail(path_md) == GRPC_ERROR_NONE);
       grpc_linked_mdelem* auth_md =
           static_cast<grpc_linked_mdelem*>(s->arena->Alloc(sizeof(*auth_md)));
       auth_md->md = grpc_mdelem_from_slices(g_fake_auth_key, g_fake_auth_value);
-      GPR_ASSERT(grpc_metadata_batch_link_tail(&fake_md, auth_md) ==
-                 GRPC_ERROR_NONE);
+      GPR_ASSERT(fake_md.LinkTail(auth_md) == GRPC_ERROR_NONE);
 
       fill_in_metadata(
           s, &fake_md, 0,

src/core/lib/surface/call.cc

@@ -936,15 +936,14 @@ static int prepare_application_metadata(grpc_call* call, int count,
     } else {
       for (i = 0; i < call->send_extra_metadata_count; i++) {
         GRPC_LOG_IF_ERROR("prepare_application_metadata",
-                          grpc_metadata_batch_link_tail(
-                              batch, &call->send_extra_metadata[i]));
+                          batch->LinkTail(&call->send_extra_metadata[i]));
       }
     }
   }
   for (i = 0; i < total_count; i++) {
     grpc_metadata* md = get_md_elem(metadata, additional_metadata, i, count);
     grpc_linked_mdelem* l = linked_from_md(md);
-    grpc_error_handle error = grpc_metadata_batch_link_tail(batch, l);
+    grpc_error_handle error = batch->LinkTail(l);
     if (error != GRPC_ERROR_NONE) {
       GRPC_MDELEM_UNREF(l->md);
     }

src/cpp/common/channel_filter.cc

@@ -33,8 +33,7 @@ grpc_linked_mdelem* MetadataBatch::AddMetadata(const string& key,
   grpc_linked_mdelem* storage = new grpc_linked_mdelem;
   storage->md = grpc_mdelem_from_slices(SliceFromCopiedString(key),
                                         SliceFromCopiedString(value));
-  GRPC_LOG_IF_ERROR("MetadataBatch::AddMetadata",
-                    grpc_metadata_batch_link_head(batch_, storage));
+  GRPC_LOG_IF_ERROR("MetadataBatch::AddMetadata", batch_->LinkHead(storage));
   return storage;
 }
 

test/core/transport/metadata_test.cc

@@ -371,8 +371,7 @@ static void test_grpc_metadata_batch_get_value_returns_one_value(void) {
     storage.md = grpc_mdelem_from_slices(
         grpc_slice_intern(grpc_slice_from_static_string(kKey)),
         grpc_slice_intern(grpc_slice_from_static_string(kValue)));
-    GPR_ASSERT(grpc_metadata_batch_link_head(&metadata, &storage) ==
-               GRPC_ERROR_NONE);
+    GPR_ASSERT(metadata.LinkHead(&storage) == GRPC_ERROR_NONE);
     std::string concatenated_value;
     absl::optional<absl::string_view> value =
         grpc_metadata_batch_get_value(&metadata, kKey, &concatenated_value);
@@ -394,13 +393,11 @@ static void test_grpc_metadata_batch_get_value_returns_multiple_values(void) {
     storage1.md = grpc_mdelem_from_slices(
         grpc_slice_intern(grpc_slice_from_static_string(kKey)),
         grpc_slice_intern(grpc_slice_from_static_string(kValue1)));
-    GPR_ASSERT(grpc_metadata_batch_link_tail(&metadata, &storage1) ==
-               GRPC_ERROR_NONE);
+    GPR_ASSERT(metadata.LinkTail(&storage1) == GRPC_ERROR_NONE);
     storage2.md = grpc_mdelem_from_slices(
         grpc_slice_intern(grpc_slice_from_static_string(kKey)),
         grpc_slice_intern(grpc_slice_from_static_string(kValue2)));
-    GPR_ASSERT(grpc_metadata_batch_link_tail(&metadata, &storage2) ==
-               GRPC_ERROR_NONE);
+    GPR_ASSERT(metadata.LinkTail(&storage2) == GRPC_ERROR_NONE);
     std::string concatenated_value;
     absl::optional<absl::string_view> value =
         grpc_metadata_batch_get_value(&metadata, kKey, &concatenated_value);