grpc 1.37.1 → 1.39.0

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

@@ -27,8 +27,9 @@
 
 #include "src/core/lib/iomgr/error.h"
 
-grpc_error* grpc_validate_header_key_is_legal(const grpc_slice& slice);
-grpc_error* grpc_validate_header_nonbin_value_is_legal(const grpc_slice& slice);
+grpc_error_handle grpc_validate_header_key_is_legal(const grpc_slice& slice);
+grpc_error_handle grpc_validate_header_nonbin_value_is_legal(
+    const grpc_slice& slice);
 
 int grpc_is_binary_header_internal(const grpc_slice& slice);
 inline int grpc_key_is_binary_header(const uint8_t* buf, size_t length) {

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

@@ -23,6 +23,8 @@
 
 #include <grpc/grpc.h>
 
-const char* grpc_version_string(void) { return "15.0.0"; }
+const char* grpc_version_string(void) { return "18.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "gilded"; }
+const char* grpc_g_stands_for(void) {
+  return "guadalupe_river_park_conservancy";
+}

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

@@ -59,7 +59,7 @@ bool SliceBufferByteStream::Next(size_t /*max_size_hint*/,
   return true;
 }
 
-grpc_error* SliceBufferByteStream::Pull(grpc_slice* slice) {
+grpc_error_handle SliceBufferByteStream::Pull(grpc_slice* slice) {
   if (GPR_UNLIKELY(shutdown_error_ != GRPC_ERROR_NONE)) {
     return GRPC_ERROR_REF(shutdown_error_);
   }
@@ -67,7 +67,7 @@ grpc_error* SliceBufferByteStream::Pull(grpc_slice* slice) {
   return GRPC_ERROR_NONE;
 }
 
-void SliceBufferByteStream::Shutdown(grpc_error* error) {
+void SliceBufferByteStream::Shutdown(grpc_error_handle error) {
   GRPC_ERROR_UNREF(shutdown_error_);
   shutdown_error_ = error;
 }
@@ -117,7 +117,7 @@ bool ByteStreamCache::CachingByteStream::Next(size_t max_size_hint,
   return cache_->underlying_stream_->Next(max_size_hint, on_complete);
 }
 
-grpc_error* ByteStreamCache::CachingByteStream::Pull(grpc_slice* slice) {
+grpc_error_handle ByteStreamCache::CachingByteStream::Pull(grpc_slice* slice) {
   if (shutdown_error_ != GRPC_ERROR_NONE) {
     return GRPC_ERROR_REF(shutdown_error_);
   }
@@ -128,7 +128,7 @@ grpc_error* ByteStreamCache::CachingByteStream::Pull(grpc_slice* slice) {
     return GRPC_ERROR_NONE;
   }
   GPR_ASSERT(cache_->underlying_stream_ != nullptr);
-  grpc_error* error = cache_->underlying_stream_->Pull(slice);
+  grpc_error_handle error = cache_->underlying_stream_->Pull(slice);
   if (error == GRPC_ERROR_NONE) {
     grpc_slice_buffer_add(&cache_->cache_buffer_,
                           grpc_slice_ref_internal(*slice));
@@ -142,7 +142,7 @@ grpc_error* ByteStreamCache::CachingByteStream::Pull(grpc_slice* slice) {
   return error;
 }
 
-void ByteStreamCache::CachingByteStream::Shutdown(grpc_error* error) {
+void ByteStreamCache::CachingByteStream::Shutdown(grpc_error_handle error) {
   GRPC_ERROR_UNREF(shutdown_error_);
   shutdown_error_ = GRPC_ERROR_REF(error);
   if (cache_->underlying_stream_ != nullptr) {

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

@@ -56,7 +56,7 @@ class ByteStream : public Orphanable {
   // indicated by Next().
   //
   // Once a slice is returned into *slice, it is owned by the caller.
-  virtual grpc_error* Pull(grpc_slice* slice) = 0;
+  virtual grpc_error_handle Pull(grpc_slice* slice) = 0;
 
   // Shuts down the byte stream.
   //
@@ -65,7 +65,7 @@ class ByteStream : public Orphanable {
   //
   // The next call to Pull() (if any) will return the error passed to
   // Shutdown().
-  virtual void Shutdown(grpc_error* error) = 0;
+  virtual void Shutdown(grpc_error_handle error) = 0;
 
   uint32_t length() const { return length_; }
   uint32_t flags() const { return flags_; }
@@ -97,11 +97,11 @@ class SliceBufferByteStream : public ByteStream {
   void Orphan() override;
 
   bool Next(size_t max_size_hint, grpc_closure* on_complete) override;
-  grpc_error* Pull(grpc_slice* slice) override;
-  void Shutdown(grpc_error* error) override;
+  grpc_error_handle Pull(grpc_slice* slice) override;
+  void Shutdown(grpc_error_handle error) override;
 
  private:
-  grpc_error* shutdown_error_ = GRPC_ERROR_NONE;
+  grpc_error_handle shutdown_error_ = GRPC_ERROR_NONE;
   grpc_slice_buffer backing_buffer_;
 };
 
@@ -131,8 +131,8 @@ class ByteStreamCache {
     void Orphan() override;
 
     bool Next(size_t max_size_hint, grpc_closure* on_complete) override;
-    grpc_error* Pull(grpc_slice* slice) override;
-    void Shutdown(grpc_error* error) override;
+    grpc_error_handle Pull(grpc_slice* slice) override;
+    void Shutdown(grpc_error_handle error) override;
 
     // Resets the byte stream to the start of the underlying stream.
     void Reset();
@@ -141,7 +141,7 @@ class ByteStreamCache {
     ByteStreamCache* cache_;
     size_t cursor_ = 0;
     size_t offset_ = 0;
-    grpc_error* shutdown_error_ = GRPC_ERROR_NONE;
+    grpc_error_handle shutdown_error_ = GRPC_ERROR_NONE;
   };
 
   explicit ByteStreamCache(OrphanablePtr<ByteStream> underlying_stream);

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

@@ -73,7 +73,7 @@ class AsyncConnectivityStateWatcherInterface::Notifier {
   }
 
  private:
-  static void SendNotification(void* arg, grpc_error* /*ignored*/) {
+  static void SendNotification(void* arg, grpc_error_handle /*ignored*/) {
     Notifier* self = static_cast<Notifier*>(arg);
     if (GRPC_TRACE_FLAG_ENABLED(grpc_connectivity_state_trace)) {
       gpr_log(GPR_INFO, "watcher %p: delivering async notification for %s (%s)",

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

@@ -25,8 +25,8 @@
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/transport/status_conversion.h"
 
-static grpc_error* recursively_find_error_with_field(grpc_error* error,
-                                                     grpc_error_ints which) {
+static grpc_error_handle recursively_find_error_with_field(
+    grpc_error_handle error, grpc_error_ints which) {
   intptr_t unused;
   // If the error itself has a status code, return it.
   if (grpc_error_get_int(error, which, &unused)) {
@@ -38,14 +38,15 @@ static grpc_error* recursively_find_error_with_field(grpc_error* error,
   while (slot != UINT8_MAX) {
     grpc_linked_error* lerr =
         reinterpret_cast<grpc_linked_error*>(error->arena + slot);
-    grpc_error* result = recursively_find_error_with_field(lerr->err, which);
+    grpc_error_handle result =
+        recursively_find_error_with_field(lerr->err, which);
     if (result) return result;
     slot = lerr->next;
   }
   return nullptr;
 }
 
-void grpc_error_get_status(grpc_error* error, grpc_millis deadline,
+void grpc_error_get_status(grpc_error_handle error, grpc_millis deadline,
                            grpc_status_code* code, grpc_slice* slice,
                            grpc_http2_error_code* http_error,
                            const char** error_string) {
@@ -71,9 +72,9 @@ void grpc_error_get_status(grpc_error* error, grpc_millis deadline,
 
   // Start with the parent error and recurse through the tree of children
   // until we find the first one that has a status code.
-  grpc_error* found_error =
+  grpc_error_handle found_error =
       recursively_find_error_with_field(error, GRPC_ERROR_INT_GRPC_STATUS);
-  if (found_error == nullptr) {
+  if (found_error == GRPC_ERROR_NONE) {
     /// If no grpc-status exists, retry through the tree to find a http2 error
     /// code
     found_error =
@@ -82,7 +83,7 @@ void grpc_error_get_status(grpc_error* error, grpc_millis deadline,
 
   // If we found an error with a status code above, use that; otherwise,
   // fall back to using the parent error.
-  if (found_error == nullptr) found_error = error;
+  if (found_error == GRPC_ERROR_NONE) found_error = error;
 
   grpc_status_code status = GRPC_STATUS_UNKNOWN;
   intptr_t integer;
@@ -96,7 +97,7 @@ void grpc_error_get_status(grpc_error* error, grpc_millis deadline,
   if (code != nullptr) *code = status;
 
   if (error_string != nullptr && status != GRPC_STATUS_OK) {
-    *error_string = gpr_strdup(grpc_error_string(error));
+    *error_string = gpr_strdup(grpc_error_std_string(error).c_str());
   }
 
   if (http_error != nullptr) {
@@ -123,7 +124,7 @@ void grpc_error_get_status(grpc_error* error, grpc_millis deadline,
   }
 }
 
-absl::Status grpc_error_to_absl_status(grpc_error* error) {
+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.
@@ -136,7 +137,17 @@ absl::Status grpc_error_to_absl_status(grpc_error* error) {
                                         GRPC_SLICE_LENGTH(message)));
 }
 
-bool grpc_error_has_clear_grpc_status(grpc_error* error) {
+grpc_error_handle absl_status_to_grpc_error(absl::Status status) {
+  // Special error checks
+  if (status.ok()) {
+    return GRPC_ERROR_NONE;
+  }
+  return grpc_error_set_int(
+      GRPC_ERROR_CREATE_FROM_STRING_VIEW(status.message()),
+      GRPC_ERROR_INT_GRPC_STATUS, static_cast<grpc_status_code>(status.code()));
+}
+
+bool grpc_error_has_clear_grpc_status(grpc_error_handle error) {
   intptr_t unused;
   if (grpc_error_get_int(error, GRPC_ERROR_INT_GRPC_STATUS, &unused)) {
     return true;

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

@@ -34,19 +34,25 @@
 /// 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_error* error, grpc_millis deadline,
+void grpc_error_get_status(grpc_error_handle error, grpc_millis deadline,
                            grpc_status_code* code, grpc_slice* slice,
                            grpc_http2_error_code* http_error,
                            const char** error_string);
 
-/// Utility Function to convert a grpc_error * \a error to an absl::Status.
-/// Does NOT consume a ref to grpc_error.
-absl::Status grpc_error_to_absl_status(grpc_error* error);
+/// Utility Function to convert a grpc_error_handle  \a error to an
+/// absl::Status. Does NOT consume a ref to grpc_error.
+absl::Status grpc_error_to_absl_status(grpc_error_handle error);
+
+/// Utility function to convert an absl::Status \a status to grpc_error. Note
+/// that this method does not return "special case" errors such as
+/// GRPC_ERROR_CANCELLED, with the exception of GRPC_ERROR_NONE returned for
+/// \a absl::OkStatus().
+grpc_error_handle absl_status_to_grpc_error(absl::Status status);
 
 /// A utility function to check whether there is a clear status code that
 /// doesn't need to be guessed in \a error. This means that \a error or some
 /// child has GRPC_ERROR_INT_GRPC_STATUS set, or that it is GRPC_ERROR_NONE or
 /// GRPC_ERROR_CANCELLED
-bool grpc_error_has_clear_grpc_status(grpc_error* error);
+bool grpc_error_has_clear_grpc_status(grpc_error_handle error);
 
 #endif /* GRPC_CORE_LIB_TRANSPORT_ERROR_UTILS_H */

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

@@ -94,22 +94,23 @@ void grpc_metadata_batch_destroy(grpc_metadata_batch* batch) {
   }
 }
 
-grpc_error* grpc_attach_md_to_error(grpc_error* src, grpc_mdelem md) {
-  grpc_error* out = grpc_error_set_str(
+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* GPR_ATTRIBUTE_NOINLINE error_with_md(grpc_mdelem md) {
+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* link_callout(grpc_metadata_batch* batch,
-                                grpc_linked_mdelem* storage,
-                                grpc_metadata_batch_callouts_index idx) {
+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;
@@ -119,12 +120,12 @@ static grpc_error* link_callout(grpc_metadata_batch* batch,
   return error_with_md(storage->md);
 }
 
-static grpc_error* maybe_link_callout(grpc_metadata_batch* batch,
-                                      grpc_linked_mdelem* storage)
+static grpc_error_handle maybe_link_callout(grpc_metadata_batch* batch,
+                                            grpc_linked_mdelem* storage)
     GRPC_MUST_USE_RESULT;
 
-static grpc_error* maybe_link_callout(grpc_metadata_batch* batch,
-                                      grpc_linked_mdelem* storage) {
+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) {
@@ -145,9 +146,9 @@ static void maybe_unlink_callout(grpc_metadata_batch* batch,
   batch->idx.array[idx] = nullptr;
 }
 
-grpc_error* grpc_metadata_batch_add_head(grpc_metadata_batch* batch,
-                                         grpc_linked_mdelem* storage,
-                                         grpc_mdelem elem_to_add) {
+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);
@@ -169,10 +170,10 @@ static void link_head(grpc_mdelem_list* list, grpc_linked_mdelem* storage) {
   assert_valid_list(list);
 }
 
-grpc_error* grpc_metadata_batch_link_head(grpc_metadata_batch* batch,
-                                          grpc_linked_mdelem* storage) {
+grpc_error_handle grpc_metadata_batch_link_head(grpc_metadata_batch* batch,
+                                                grpc_linked_mdelem* storage) {
   assert_valid_callouts(batch);
-  grpc_error* err = maybe_link_callout(batch, storage);
+  grpc_error_handle err = maybe_link_callout(batch, storage);
   if (err != GRPC_ERROR_NONE) {
     assert_valid_callouts(batch);
     return err;
@@ -185,12 +186,12 @@ grpc_error* grpc_metadata_batch_link_head(grpc_metadata_batch* batch,
 // 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* grpc_metadata_batch_link_head(
+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* err = link_callout(batch, storage, idx);
+  grpc_error_handle err = link_callout(batch, storage, idx);
   if (GPR_UNLIKELY(err != GRPC_ERROR_NONE)) {
     assert_valid_callouts(batch);
     return err;
@@ -200,9 +201,9 @@ grpc_error* grpc_metadata_batch_link_head(
   return GRPC_ERROR_NONE;
 }
 
-grpc_error* grpc_metadata_batch_add_tail(grpc_metadata_batch* batch,
-                                         grpc_linked_mdelem* storage,
-                                         grpc_mdelem elem_to_add) {
+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);
@@ -224,10 +225,10 @@ static void link_tail(grpc_mdelem_list* list, grpc_linked_mdelem* storage) {
   assert_valid_list(list);
 }
 
-grpc_error* grpc_metadata_batch_link_tail(grpc_metadata_batch* batch,
-                                          grpc_linked_mdelem* storage) {
+grpc_error_handle grpc_metadata_batch_link_tail(grpc_metadata_batch* batch,
+                                                grpc_linked_mdelem* storage) {
   assert_valid_callouts(batch);
-  grpc_error* err = maybe_link_callout(batch, storage);
+  grpc_error_handle err = maybe_link_callout(batch, storage);
   if (err != GRPC_ERROR_NONE) {
     assert_valid_callouts(batch);
     return err;
@@ -237,12 +238,12 @@ grpc_error* grpc_metadata_batch_link_tail(grpc_metadata_batch* batch,
   return GRPC_ERROR_NONE;
 }
 
-grpc_error* grpc_metadata_batch_link_tail(
+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* err = link_callout(batch, storage, idx);
+  grpc_error_handle err = link_callout(batch, storage, idx);
   if (GPR_UNLIKELY(err != GRPC_ERROR_NONE)) {
     assert_valid_callouts(batch);
     return err;
@@ -323,11 +324,11 @@ absl::optional<absl::string_view> grpc_metadata_batch_get_value(
   return *concatenated_value;
 }
 
-grpc_error* grpc_metadata_batch_substitute(grpc_metadata_batch* batch,
-                                           grpc_linked_mdelem* storage,
-                                           grpc_mdelem new_mdelem) {
+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* error = GRPC_ERROR_NONE;
+  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);
@@ -364,7 +365,7 @@ size_t grpc_metadata_batch_size(grpc_metadata_batch* batch) {
   return size;
 }
 
-static void add_error(grpc_error** composite, grpc_error* error,
+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) {
@@ -373,12 +374,11 @@ static void add_error(grpc_error** composite, grpc_error* error,
   *composite = grpc_error_add_child(*composite, error);
 }
 
-grpc_error* grpc_metadata_batch_filter(grpc_metadata_batch* batch,
-                                       grpc_metadata_batch_filter_func func,
-                                       void* user_data,
-                                       const char* composite_error_string) {
+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* error = GRPC_ERROR_NONE;
+  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);
@@ -402,7 +402,7 @@ void grpc_metadata_batch_copy(grpc_metadata_batch* src,
   for (grpc_linked_mdelem* elem = src->list.head; elem != nullptr;
        elem = elem->next) {
     // Error unused in non-debug builds.
-    grpc_error* GRPC_UNUSED error = grpc_metadata_batch_add_tail(
+    grpc_error_handle GRPC_UNUSED error = grpc_metadata_batch_add_tail(
         dst, &storage[i++], GRPC_MDELEM_REF(elem->md));
     // The only way that grpc_metadata_batch_add_tail() can fail is if
     // there's a duplicate entry for a callout.  However, that can't be

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

@@ -74,9 +74,9 @@ void grpc_metadata_batch_remove(grpc_metadata_batch* batch,
                                 grpc_metadata_batch_callouts_index idx);
 
 /** Substitute a new mdelem for an old value */
-grpc_error* grpc_metadata_batch_substitute(grpc_metadata_batch* batch,
-                                           grpc_linked_mdelem* storage,
-                                           grpc_mdelem new_mdelem);
+grpc_error_handle grpc_metadata_batch_substitute(grpc_metadata_batch* batch,
+                                                 grpc_linked_mdelem* storage,
+                                                 grpc_mdelem new_mdelem);
 
 void grpc_metadata_batch_set_value(grpc_linked_mdelem* storage,
                                    const grpc_slice& value);
@@ -97,10 +97,10 @@ absl::optional<absl::string_view> grpc_metadata_batch_get_value(
     \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_metadata_batch* batch,
-                                          grpc_linked_mdelem* storage)
+grpc_error_handle grpc_metadata_batch_link_head(grpc_metadata_batch* batch,
+                                                grpc_linked_mdelem* storage)
     GRPC_MUST_USE_RESULT;
-grpc_error* grpc_metadata_batch_link_head(
+grpc_error_handle grpc_metadata_batch_link_head(
     grpc_metadata_batch* batch, grpc_linked_mdelem* storage,
     grpc_metadata_batch_callouts_index idx) GRPC_MUST_USE_RESULT;
 
@@ -109,10 +109,10 @@ grpc_error* grpc_metadata_batch_link_head(
     \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_metadata_batch* batch,
-                                          grpc_linked_mdelem* storage)
+grpc_error_handle grpc_metadata_batch_link_tail(grpc_metadata_batch* batch,
+                                                grpc_linked_mdelem* storage)
     GRPC_MUST_USE_RESULT;
-grpc_error* grpc_metadata_batch_link_tail(
+grpc_error_handle grpc_metadata_batch_link_tail(
     grpc_metadata_batch* batch, grpc_linked_mdelem* storage,
     grpc_metadata_batch_callouts_index idx) GRPC_MUST_USE_RESULT;
 
@@ -122,19 +122,19 @@ grpc_error* grpc_metadata_batch_link_tail(
     lifetime of batch. This usually means it should be around
     for the lifetime of the call.
     Takes ownership of \a elem_to_add */
-grpc_error* grpc_metadata_batch_add_head(
+grpc_error_handle grpc_metadata_batch_add_head(
     grpc_metadata_batch* batch, grpc_linked_mdelem* storage,
     grpc_mdelem elem_to_add) GRPC_MUST_USE_RESULT;
 
 // TODO(arjunroy, roth): Remove redundant methods.
 // add/link_head/tail are almost identical.
-inline grpc_error* GRPC_MUST_USE_RESULT grpc_metadata_batch_add_head(
+inline grpc_error_handle GRPC_MUST_USE_RESULT grpc_metadata_batch_add_head(
     grpc_metadata_batch* batch, grpc_linked_mdelem* storage,
     grpc_metadata_batch_callouts_index idx) {
   return grpc_metadata_batch_link_head(batch, storage, idx);
 }
 
-inline grpc_error* GRPC_MUST_USE_RESULT grpc_metadata_batch_add_head(
+inline grpc_error_handle GRPC_MUST_USE_RESULT grpc_metadata_batch_add_head(
     grpc_metadata_batch* batch, grpc_linked_mdelem* storage,
     grpc_mdelem elem_to_add, grpc_metadata_batch_callouts_index idx) {
   GPR_DEBUG_ASSERT(!GRPC_MDISNULL(elem_to_add));
@@ -148,17 +148,17 @@ inline grpc_error* GRPC_MUST_USE_RESULT grpc_metadata_batch_add_head(
     lifetime of batch. This usually means it should be around
     for the lifetime of the call.
     Takes ownership of \a elem_to_add */
-grpc_error* grpc_metadata_batch_add_tail(
+grpc_error_handle grpc_metadata_batch_add_tail(
     grpc_metadata_batch* batch, grpc_linked_mdelem* storage,
     grpc_mdelem elem_to_add) GRPC_MUST_USE_RESULT;
 
-inline grpc_error* GRPC_MUST_USE_RESULT grpc_metadata_batch_add_tail(
+inline grpc_error_handle GRPC_MUST_USE_RESULT grpc_metadata_batch_add_tail(
     grpc_metadata_batch* batch, grpc_linked_mdelem* storage,
     grpc_metadata_batch_callouts_index idx) {
   return grpc_metadata_batch_link_tail(batch, storage, idx);
 }
 
-inline grpc_error* GRPC_MUST_USE_RESULT grpc_metadata_batch_add_tail(
+inline grpc_error_handle GRPC_MUST_USE_RESULT grpc_metadata_batch_add_tail(
     grpc_metadata_batch* batch, grpc_linked_mdelem* storage,
     grpc_mdelem elem_to_add, grpc_metadata_batch_callouts_index idx) {
   GPR_DEBUG_ASSERT(!GRPC_MDISNULL(elem_to_add));
@@ -166,10 +166,11 @@ inline grpc_error* GRPC_MUST_USE_RESULT grpc_metadata_batch_add_tail(
   return grpc_metadata_batch_add_tail(batch, storage, idx);
 }
 
-grpc_error* grpc_attach_md_to_error(grpc_error* src, grpc_mdelem md);
+grpc_error_handle grpc_attach_md_to_error(grpc_error_handle src,
+                                          grpc_mdelem md);
 
 struct grpc_filtered_mdelem {
-  grpc_error* error;
+  grpc_error_handle error;
   grpc_mdelem md;
 };
 #define GRPC_FILTERED_ERROR(error) \
@@ -181,7 +182,7 @@ struct grpc_filtered_mdelem {
 
 typedef grpc_filtered_mdelem (*grpc_metadata_batch_filter_func)(
     void* user_data, grpc_mdelem elem);
-grpc_error* grpc_metadata_batch_filter(
+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_MUST_USE_RESULT;