grpc 1.8.7 → 1.9.0.pre1

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

@@ -23,10 +23,6 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/transport/http2_errors.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /// A utility function to get the status code and message to be returned
 /// to the application.  If not set in the top-level message, looks
 /// through child errors until it finds the first one with these attributes.
@@ -34,9 +30,8 @@ extern "C" {
 /// be populated with the entire error string. If any of the attributes (code,
 /// msg, http_status, error_string) are unneeded, they can be passed as
 /// NULL.
-void grpc_error_get_status(grpc_exec_ctx* exec_ctx, grpc_error* error,
-                           grpc_millis deadline, grpc_status_code* code,
-                           grpc_slice* slice,
+void grpc_error_get_status(grpc_error* error, grpc_millis deadline,
+                           grpc_status_code* code, grpc_slice* slice,
                            grpc_http2_error_code* http_status,
                            const char** error_string);
 
@@ -46,8 +41,4 @@ void grpc_error_get_status(grpc_exec_ctx* exec_ctx, grpc_error* error,
 /// GRPC_ERROR_CANCELLED
 bool grpc_error_has_clear_grpc_status(grpc_error* error);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_TRANSPORT_ERROR_UTILS_H */

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

@@ -31,12 +31,12 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/time.h>
 
+#include "src/core/lib/gpr/murmur_hash.h"
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
-#include "src/core/lib/support/murmur_hash.h"
-#include "src/core/lib/support/string.h"
 #include "src/core/lib/transport/static_metadata.h"
 
 /* There are two kinds of mdelem and mdstr instances.
@@ -108,7 +108,7 @@ typedef struct mdtab_shard {
 
 static mdtab_shard g_shards[SHARD_COUNT];
 
-static void gc_mdtab(grpc_exec_ctx* exec_ctx, mdtab_shard* shard);
+static void gc_mdtab(mdtab_shard* shard);
 
 void grpc_mdctx_global_init(void) {
   /* initialize shards */
@@ -123,11 +123,11 @@ void grpc_mdctx_global_init(void) {
   }
 }
 
-void grpc_mdctx_global_shutdown(grpc_exec_ctx* exec_ctx) {
+void grpc_mdctx_global_shutdown() {
   for (size_t i = 0; i < SHARD_COUNT; i++) {
     mdtab_shard* shard = &g_shards[i];
     gpr_mu_destroy(&shard->mu);
-    gc_mdtab(exec_ctx, shard);
+    gc_mdtab(shard);
     /* TODO(ctiller): GPR_ASSERT(shard->count == 0); */
     if (shard->count != 0) {
       gpr_log(GPR_DEBUG, "WARNING: %" PRIuPTR " metadata elements were leaked",
@@ -165,7 +165,7 @@ static void ref_md_locked(mdtab_shard* shard,
   }
 }
 
-static void gc_mdtab(grpc_exec_ctx* exec_ctx, mdtab_shard* shard) {
+static void gc_mdtab(mdtab_shard* shard) {
   size_t i;
   interned_metadata** prev_next;
   interned_metadata *md, *next;
@@ -178,8 +178,8 @@ static void gc_mdtab(grpc_exec_ctx* exec_ctx, mdtab_shard* shard) {
       void* user_data = (void*)gpr_atm_no_barrier_load(&md->user_data);
       next = md->bucket_next;
       if (gpr_atm_acq_load(&md->refcnt) == 0) {
-        grpc_slice_unref_internal(exec_ctx, md->key);
-        grpc_slice_unref_internal(exec_ctx, md->value);
+        grpc_slice_unref_internal(md->key);
+        grpc_slice_unref_internal(md->value);
         if (md->user_data) {
           ((destroy_user_data_func)gpr_atm_no_barrier_load(
               &md->destroy_user_data))(user_data);
@@ -228,17 +228,17 @@ static void grow_mdtab(mdtab_shard* shard) {
   GPR_TIMER_END("grow_mdtab", 0);
 }
 
-static void rehash_mdtab(grpc_exec_ctx* exec_ctx, mdtab_shard* shard) {
+static void rehash_mdtab(mdtab_shard* shard) {
   if (gpr_atm_no_barrier_load(&shard->free_estimate) >
       (gpr_atm)(shard->capacity / 4)) {
-    gc_mdtab(exec_ctx, shard);
+    gc_mdtab(shard);
   } else {
     grow_mdtab(shard);
   }
 }
 
 grpc_mdelem grpc_mdelem_create(
-    grpc_exec_ctx* exec_ctx, grpc_slice key, grpc_slice value,
+    grpc_slice key, grpc_slice value,
     grpc_mdelem_data* compatible_external_backing_store) {
   if (!grpc_slice_is_interned(key) || !grpc_slice_is_interned(value)) {
     if (compatible_external_backing_store != nullptr) {
@@ -318,7 +318,7 @@ grpc_mdelem grpc_mdelem_create(
   shard->count++;
 
   if (shard->count > shard->capacity * 2) {
-    rehash_mdtab(exec_ctx, shard);
+    rehash_mdtab(shard);
   }
 
   gpr_mu_unlock(&shard->mu);
@@ -328,22 +328,20 @@ grpc_mdelem grpc_mdelem_create(
   return GRPC_MAKE_MDELEM(md, GRPC_MDELEM_STORAGE_INTERNED);
 }
 
-grpc_mdelem grpc_mdelem_from_slices(grpc_exec_ctx* exec_ctx, grpc_slice key,
-                                    grpc_slice value) {
-  grpc_mdelem out = grpc_mdelem_create(exec_ctx, key, value, nullptr);
-  grpc_slice_unref_internal(exec_ctx, key);
-  grpc_slice_unref_internal(exec_ctx, value);
+grpc_mdelem grpc_mdelem_from_slices(grpc_slice key, grpc_slice value) {
+  grpc_mdelem out = grpc_mdelem_create(key, value, nullptr);
+  grpc_slice_unref_internal(key);
+  grpc_slice_unref_internal(value);
   return out;
 }
 
-grpc_mdelem grpc_mdelem_from_grpc_metadata(grpc_exec_ctx* exec_ctx,
-                                           grpc_metadata* metadata) {
+grpc_mdelem grpc_mdelem_from_grpc_metadata(grpc_metadata* metadata) {
   bool changed = false;
   grpc_slice key_slice =
       grpc_slice_maybe_static_intern(metadata->key, &changed);
   grpc_slice value_slice =
       grpc_slice_maybe_static_intern(metadata->value, &changed);
-  return grpc_mdelem_create(exec_ctx, key_slice, value_slice,
+  return grpc_mdelem_create(key_slice, value_slice,
                             changed ? nullptr : (grpc_mdelem_data*)metadata);
 }
 
@@ -417,7 +415,7 @@ grpc_mdelem grpc_mdelem_ref(grpc_mdelem gmd DEBUG_ARGS) {
   return gmd;
 }
 
-void grpc_mdelem_unref(grpc_exec_ctx* exec_ctx, grpc_mdelem gmd DEBUG_ARGS) {
+void grpc_mdelem_unref(grpc_mdelem gmd DEBUG_ARGS) {
   switch (GRPC_MDELEM_STORAGE(gmd)) {
     case GRPC_MDELEM_STORAGE_EXTERNAL:
     case GRPC_MDELEM_STORAGE_STATIC:
@@ -465,8 +463,8 @@ void grpc_mdelem_unref(grpc_exec_ctx* exec_ctx, grpc_mdelem gmd DEBUG_ARGS) {
       const gpr_atm prev_refcount = gpr_atm_full_fetch_add(&md->refcnt, -1);
       GPR_ASSERT(prev_refcount >= 1);
       if (1 == prev_refcount) {
-        grpc_slice_unref_internal(exec_ctx, md->key);
-        grpc_slice_unref_internal(exec_ctx, md->value);
+        grpc_slice_unref_internal(md->key);
+        grpc_slice_unref_internal(md->value);
         gpr_free(md);
       }
       break;

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

@@ -27,10 +27,6 @@
 
 extern grpc_core::DebugOnlyTraceFlag grpc_trace_metadata;
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /* This file provides a mechanism for tracking metadata through the grpc stack.
    It's not intended for consumption outside of the library.
 
@@ -111,20 +107,18 @@ struct grpc_mdelem {
                               (uintptr_t)GRPC_MDELEM_STORAGE_INTERNED_BIT))
 
 /* Unrefs the slices. */
-grpc_mdelem grpc_mdelem_from_slices(grpc_exec_ctx* exec_ctx, grpc_slice key,
-                                    grpc_slice value);
+grpc_mdelem grpc_mdelem_from_slices(grpc_slice key, grpc_slice value);
 
 /* Cheaply convert a grpc_metadata to a grpc_mdelem; may use the grpc_metadata
    object as backing storage (so lifetimes should align) */
-grpc_mdelem grpc_mdelem_from_grpc_metadata(grpc_exec_ctx* exec_ctx,
-                                           grpc_metadata* metadata);
+grpc_mdelem grpc_mdelem_from_grpc_metadata(grpc_metadata* metadata);
 
 /* Does not unref the slices; if a new non-interned mdelem is needed, allocates
    one if compatible_external_backing_store is NULL, or uses
    compatible_external_backing_store if it is non-NULL (in which case it's the
    users responsibility to ensure that it outlives usage) */
 grpc_mdelem grpc_mdelem_create(
-    grpc_exec_ctx* exec_ctx, grpc_slice key, grpc_slice value,
+    grpc_slice key, grpc_slice value,
     grpc_mdelem_data* compatible_external_backing_store);
 
 bool grpc_mdelem_eq(grpc_mdelem a, grpc_mdelem b);
@@ -140,16 +134,14 @@ void* grpc_mdelem_set_user_data(grpc_mdelem md, void (*destroy_func)(void*),
 
 #ifndef NDEBUG
 #define GRPC_MDELEM_REF(s) grpc_mdelem_ref((s), __FILE__, __LINE__)
-#define GRPC_MDELEM_UNREF(exec_ctx, s) \
-  grpc_mdelem_unref((exec_ctx), (s), __FILE__, __LINE__)
+#define GRPC_MDELEM_UNREF(s) grpc_mdelem_unref((s), __FILE__, __LINE__)
 grpc_mdelem grpc_mdelem_ref(grpc_mdelem md, const char* file, int line);
-void grpc_mdelem_unref(grpc_exec_ctx* exec_ctx, grpc_mdelem md,
-                       const char* file, int line);
+void grpc_mdelem_unref(grpc_mdelem md, const char* file, int line);
 #else
 #define GRPC_MDELEM_REF(s) grpc_mdelem_ref((s))
-#define GRPC_MDELEM_UNREF(exec_ctx, s) grpc_mdelem_unref((exec_ctx), (s))
+#define GRPC_MDELEM_UNREF(s) grpc_mdelem_unref((s))
 grpc_mdelem grpc_mdelem_ref(grpc_mdelem md);
-void grpc_mdelem_unref(grpc_exec_ctx* exec_ctx, grpc_mdelem md);
+void grpc_mdelem_unref(grpc_mdelem md);
 #endif
 
 #define GRPC_MDKEY(md) (GRPC_MDELEM_DATA(md)->key)
@@ -166,10 +158,6 @@ void grpc_mdelem_unref(grpc_exec_ctx* exec_ctx, grpc_mdelem md);
 #define GRPC_MDSTR_KV_HASH(k_hash, v_hash) (GPR_ROTL((k_hash), 2) ^ (v_hash))
 
 void grpc_mdctx_global_init(void);
-void grpc_mdctx_global_shutdown(grpc_exec_ctx* exec_ctx);
-
-#ifdef __cplusplus
-}
-#endif
+void grpc_mdctx_global_shutdown();
 
 #endif /* GRPC_CORE_LIB_TRANSPORT_METADATA_H */

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

@@ -51,8 +51,7 @@ static void assert_valid_list(grpc_mdelem_list* list) {
 #endif /* NDEBUG */
 }
 
-static void assert_valid_callouts(grpc_exec_ctx* exec_ctx,
-                                  grpc_metadata_batch* batch) {
+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));
@@ -61,7 +60,7 @@ static void assert_valid_callouts(grpc_exec_ctx* exec_ctx,
     if (callout_idx != GRPC_BATCH_CALLOUTS_COUNT) {
       GPR_ASSERT(batch->idx.array[callout_idx] == l);
     }
-    grpc_slice_unref_internal(exec_ctx, key_interned);
+    grpc_slice_unref_internal(key_interned);
   }
 #endif
 }
@@ -77,11 +76,10 @@ void grpc_metadata_batch_init(grpc_metadata_batch* batch) {
   batch->deadline = GRPC_MILLIS_INF_FUTURE;
 }
 
-void grpc_metadata_batch_destroy(grpc_exec_ctx* exec_ctx,
-                                 grpc_metadata_batch* batch) {
+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(exec_ctx, l->md);
+    GRPC_MDELEM_UNREF(l->md);
   }
 }
 
@@ -126,13 +124,12 @@ static void maybe_unlink_callout(grpc_metadata_batch* batch,
   batch->idx.array[idx] = nullptr;
 }
 
-grpc_error* grpc_metadata_batch_add_head(grpc_exec_ctx* exec_ctx,
-                                         grpc_metadata_batch* batch,
+grpc_error* grpc_metadata_batch_add_head(grpc_metadata_batch* batch,
                                          grpc_linked_mdelem* storage,
                                          grpc_mdelem elem_to_add) {
   GPR_ASSERT(!GRPC_MDISNULL(elem_to_add));
   storage->md = elem_to_add;
-  return grpc_metadata_batch_link_head(exec_ctx, batch, storage);
+  return grpc_metadata_batch_link_head(batch, storage);
 }
 
 static void link_head(grpc_mdelem_list* list, grpc_linked_mdelem* storage) {
@@ -150,27 +147,25 @@ static void link_head(grpc_mdelem_list* list, grpc_linked_mdelem* storage) {
   assert_valid_list(list);
 }
 
-grpc_error* grpc_metadata_batch_link_head(grpc_exec_ctx* exec_ctx,
-                                          grpc_metadata_batch* batch,
+grpc_error* grpc_metadata_batch_link_head(grpc_metadata_batch* batch,
                                           grpc_linked_mdelem* storage) {
-  assert_valid_callouts(exec_ctx, batch);
+  assert_valid_callouts(batch);
   grpc_error* err = maybe_link_callout(batch, storage);
   if (err != GRPC_ERROR_NONE) {
-    assert_valid_callouts(exec_ctx, batch);
+    assert_valid_callouts(batch);
     return err;
   }
   link_head(&batch->list, storage);
-  assert_valid_callouts(exec_ctx, batch);
+  assert_valid_callouts(batch);
   return GRPC_ERROR_NONE;
 }
 
-grpc_error* grpc_metadata_batch_add_tail(grpc_exec_ctx* exec_ctx,
-                                         grpc_metadata_batch* batch,
+grpc_error* grpc_metadata_batch_add_tail(grpc_metadata_batch* batch,
                                          grpc_linked_mdelem* storage,
                                          grpc_mdelem elem_to_add) {
   GPR_ASSERT(!GRPC_MDISNULL(elem_to_add));
   storage->md = elem_to_add;
-  return grpc_metadata_batch_link_tail(exec_ctx, batch, storage);
+  return grpc_metadata_batch_link_tail(batch, storage);
 }
 
 static void link_tail(grpc_mdelem_list* list, grpc_linked_mdelem* storage) {
@@ -189,17 +184,16 @@ static void link_tail(grpc_mdelem_list* list, grpc_linked_mdelem* storage) {
   assert_valid_list(list);
 }
 
-grpc_error* grpc_metadata_batch_link_tail(grpc_exec_ctx* exec_ctx,
-                                          grpc_metadata_batch* batch,
+grpc_error* grpc_metadata_batch_link_tail(grpc_metadata_batch* batch,
                                           grpc_linked_mdelem* storage) {
-  assert_valid_callouts(exec_ctx, batch);
+  assert_valid_callouts(batch);
   grpc_error* err = maybe_link_callout(batch, storage);
   if (err != GRPC_ERROR_NONE) {
-    assert_valid_callouts(exec_ctx, batch);
+    assert_valid_callouts(batch);
     return err;
   }
   link_tail(&batch->list, storage);
-  assert_valid_callouts(exec_ctx, batch);
+  assert_valid_callouts(batch);
   return GRPC_ERROR_NONE;
 }
 
@@ -220,31 +214,28 @@ static void unlink_storage(grpc_mdelem_list* list,
   assert_valid_list(list);
 }
 
-void grpc_metadata_batch_remove(grpc_exec_ctx* exec_ctx,
-                                grpc_metadata_batch* batch,
+void grpc_metadata_batch_remove(grpc_metadata_batch* batch,
                                 grpc_linked_mdelem* storage) {
-  assert_valid_callouts(exec_ctx, batch);
+  assert_valid_callouts(batch);
   maybe_unlink_callout(batch, storage);
   unlink_storage(&batch->list, storage);
-  GRPC_MDELEM_UNREF(exec_ctx, storage->md);
-  assert_valid_callouts(exec_ctx, batch);
+  GRPC_MDELEM_UNREF(storage->md);
+  assert_valid_callouts(batch);
 }
 
-void grpc_metadata_batch_set_value(grpc_exec_ctx* exec_ctx,
-                                   grpc_linked_mdelem* storage,
+void grpc_metadata_batch_set_value(grpc_linked_mdelem* storage,
                                    grpc_slice value) {
   grpc_mdelem old_mdelem = storage->md;
   grpc_mdelem new_mdelem = grpc_mdelem_from_slices(
-      exec_ctx, grpc_slice_ref_internal(GRPC_MDKEY(old_mdelem)), value);
+      grpc_slice_ref_internal(GRPC_MDKEY(old_mdelem)), value);
   storage->md = new_mdelem;
-  GRPC_MDELEM_UNREF(exec_ctx, old_mdelem);
+  GRPC_MDELEM_UNREF(old_mdelem);
 }
 
-grpc_error* grpc_metadata_batch_substitute(grpc_exec_ctx* exec_ctx,
-                                           grpc_metadata_batch* batch,
+grpc_error* grpc_metadata_batch_substitute(grpc_metadata_batch* batch,
                                            grpc_linked_mdelem* storage,
                                            grpc_mdelem new_mdelem) {
-  assert_valid_callouts(exec_ctx, batch);
+  assert_valid_callouts(batch);
   grpc_error* error = GRPC_ERROR_NONE;
   grpc_mdelem old_mdelem = storage->md;
   if (!grpc_slice_eq(GRPC_MDKEY(new_mdelem), GRPC_MDKEY(old_mdelem))) {
@@ -253,19 +244,18 @@ grpc_error* grpc_metadata_batch_substitute(grpc_exec_ctx* exec_ctx,
     error = maybe_link_callout(batch, storage);
     if (error != GRPC_ERROR_NONE) {
       unlink_storage(&batch->list, storage);
-      GRPC_MDELEM_UNREF(exec_ctx, storage->md);
+      GRPC_MDELEM_UNREF(storage->md);
     }
   } else {
     storage->md = new_mdelem;
   }
-  GRPC_MDELEM_UNREF(exec_ctx, old_mdelem);
-  assert_valid_callouts(exec_ctx, batch);
+  GRPC_MDELEM_UNREF(old_mdelem);
+  assert_valid_callouts(batch);
   return error;
 }
 
-void grpc_metadata_batch_clear(grpc_exec_ctx* exec_ctx,
-                               grpc_metadata_batch* batch) {
-  grpc_metadata_batch_destroy(exec_ctx, batch);
+void grpc_metadata_batch_clear(grpc_metadata_batch* batch) {
+  grpc_metadata_batch_destroy(batch);
   grpc_metadata_batch_init(batch);
 }
 
@@ -292,8 +282,7 @@ static void add_error(grpc_error** composite, grpc_error* error,
   *composite = grpc_error_add_child(*composite, error);
 }
 
-grpc_error* grpc_metadata_batch_filter(grpc_exec_ctx* exec_ctx,
-                                       grpc_metadata_batch* batch,
+grpc_error* grpc_metadata_batch_filter(grpc_metadata_batch* batch,
                                        grpc_metadata_batch_filter_func func,
                                        void* user_data,
                                        const char* composite_error_string) {
@@ -301,12 +290,12 @@ grpc_error* grpc_metadata_batch_filter(grpc_exec_ctx* exec_ctx,
   grpc_error* error = GRPC_ERROR_NONE;
   while (l) {
     grpc_linked_mdelem* next = l->next;
-    grpc_filtered_mdelem new_mdelem = func(exec_ctx, user_data, l->md);
+    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(exec_ctx, batch, l);
+      grpc_metadata_batch_remove(batch, l);
     } else if (new_mdelem.md.payload != l->md.payload) {
-      grpc_metadata_batch_substitute(exec_ctx, batch, l, new_mdelem.md);
+      grpc_metadata_batch_substitute(batch, l, new_mdelem.md);
     }
     l = next;
   }

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

@@ -28,10 +28,6 @@
 #include "src/core/lib/transport/metadata.h"
 #include "src/core/lib/transport/static_metadata.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 typedef struct grpc_linked_mdelem {
   grpc_mdelem md;
   struct grpc_linked_mdelem* next;
@@ -57,28 +53,23 @@ typedef struct grpc_metadata_batch {
 } grpc_metadata_batch;
 
 void grpc_metadata_batch_init(grpc_metadata_batch* batch);
-void grpc_metadata_batch_destroy(grpc_exec_ctx* exec_ctx,
-                                 grpc_metadata_batch* batch);
-void grpc_metadata_batch_clear(grpc_exec_ctx* exec_ctx,
-                               grpc_metadata_batch* batch);
+void grpc_metadata_batch_destroy(grpc_metadata_batch* batch);
+void grpc_metadata_batch_clear(grpc_metadata_batch* batch);
 bool grpc_metadata_batch_is_empty(grpc_metadata_batch* batch);
 
 /* Returns the transport size of the batch. */
 size_t grpc_metadata_batch_size(grpc_metadata_batch* batch);
 
 /** Remove \a storage from the batch, unreffing the mdelem contained */
-void grpc_metadata_batch_remove(grpc_exec_ctx* exec_ctx,
-                                grpc_metadata_batch* batch,
+void grpc_metadata_batch_remove(grpc_metadata_batch* batch,
                                 grpc_linked_mdelem* storage);
 
 /** Substitute a new mdelem for an old value */
-grpc_error* grpc_metadata_batch_substitute(grpc_exec_ctx* exec_ctx,
-                                           grpc_metadata_batch* batch,
+grpc_error* grpc_metadata_batch_substitute(grpc_metadata_batch* batch,
                                            grpc_linked_mdelem* storage,
                                            grpc_mdelem new_value);
 
-void grpc_metadata_batch_set_value(grpc_exec_ctx* exec_ctx,
-                                   grpc_linked_mdelem* storage,
+void grpc_metadata_batch_set_value(grpc_linked_mdelem* storage,
                                    grpc_slice value);
 
 /** Add \a storage to the beginning of \a batch. storage->md is
@@ -86,17 +77,17 @@ void grpc_metadata_batch_set_value(grpc_exec_ctx* exec_ctx,
     \a storage is owned by the caller and must survive for the
     lifetime of batch. This usually means it should be around
     for the lifetime of the call. */
-grpc_error* grpc_metadata_batch_link_head(
-    grpc_exec_ctx* exec_ctx, grpc_metadata_batch* batch,
-    grpc_linked_mdelem* storage) GRPC_MUST_USE_RESULT;
+grpc_error* grpc_metadata_batch_link_head(grpc_metadata_batch* batch,
+                                          grpc_linked_mdelem* storage)
+    GRPC_MUST_USE_RESULT;
 /** Add \a storage to the end of \a batch. storage->md is
     assumed to be valid.
     \a storage is owned by the caller and must survive for the
     lifetime of batch. This usually means it should be around
     for the lifetime of the call. */
-grpc_error* grpc_metadata_batch_link_tail(
-    grpc_exec_ctx* exec_ctx, grpc_metadata_batch* batch,
-    grpc_linked_mdelem* storage) GRPC_MUST_USE_RESULT;
+grpc_error* grpc_metadata_batch_link_tail(grpc_metadata_batch* batch,
+                                          grpc_linked_mdelem* storage)
+    GRPC_MUST_USE_RESULT;
 
 /** Add \a elem_to_add as the first element in \a batch, using
     \a storage as backing storage for the linked list element.
@@ -105,8 +96,8 @@ grpc_error* grpc_metadata_batch_link_tail(
     for the lifetime of the call.
     Takes ownership of \a elem_to_add */
 grpc_error* grpc_metadata_batch_add_head(
-    grpc_exec_ctx* exec_ctx, grpc_metadata_batch* batch,
-    grpc_linked_mdelem* storage, grpc_mdelem elem_to_add) GRPC_MUST_USE_RESULT;
+    grpc_metadata_batch* batch, grpc_linked_mdelem* storage,
+    grpc_mdelem elem_to_add) GRPC_MUST_USE_RESULT;
 /** Add \a elem_to_add as the last element in \a batch, using
     \a storage as backing storage for the linked list element.
     \a storage is owned by the caller and must survive for the
@@ -114,8 +105,8 @@ grpc_error* grpc_metadata_batch_add_head(
     for the lifetime of the call.
     Takes ownership of \a elem_to_add */
 grpc_error* grpc_metadata_batch_add_tail(
-    grpc_exec_ctx* exec_ctx, grpc_metadata_batch* batch,
-    grpc_linked_mdelem* storage, grpc_mdelem elem_to_add) GRPC_MUST_USE_RESULT;
+    grpc_metadata_batch* batch, grpc_linked_mdelem* storage,
+    grpc_mdelem elem_to_add) GRPC_MUST_USE_RESULT;
 
 grpc_error* grpc_attach_md_to_error(grpc_error* src, grpc_mdelem md);
 
@@ -132,11 +123,10 @@ typedef struct {
   { GRPC_ERROR_NONE, GRPC_MDNULL }
 
 typedef grpc_filtered_mdelem (*grpc_metadata_batch_filter_func)(
-    grpc_exec_ctx* exec_ctx, void* user_data, grpc_mdelem elem);
+    void* user_data, grpc_mdelem elem);
 grpc_error* grpc_metadata_batch_filter(
-    grpc_exec_ctx* exec_ctx, grpc_metadata_batch* batch,
-    grpc_metadata_batch_filter_func func, void* user_data,
-    const char* composite_error_string) GRPC_MUST_USE_RESULT;
+    grpc_metadata_batch* batch, grpc_metadata_batch_filter_func func,
+    void* user_data, const char* composite_error_string) GRPC_MUST_USE_RESULT;
 
 #ifndef NDEBUG
 void grpc_metadata_batch_assert_ok(grpc_metadata_batch* comd);
@@ -146,8 +136,4 @@ void grpc_metadata_batch_assert_ok(grpc_metadata_batch* comd);
   } while (0)
 #endif
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_TRANSPORT_METADATA_BATCH_H */