grpc 1.36.0 → 1.38.0

data/src/core/ext/filters/http/client_authority_filter.cc

@@ -57,7 +57,7 @@ void client_authority_start_transport_stream_op_batch(
   if (batch->send_initial_metadata &&
       batch->payload->send_initial_metadata.send_initial_metadata->idx.named
               .authority == nullptr) {
-    grpc_error* error = grpc_metadata_batch_add_head(
+    grpc_error_handle error = grpc_metadata_batch_add_head(
         batch->payload->send_initial_metadata.send_initial_metadata,
         &calld->authority_storage,
         GRPC_MDELEM_REF(chand->default_authority_mdelem), GRPC_BATCH_AUTHORITY);
@@ -72,7 +72,7 @@ void client_authority_start_transport_stream_op_batch(
 }
 
 /* Constructor for call_data */
-grpc_error* client_authority_init_call_elem(
+grpc_error_handle client_authority_init_call_elem(
     grpc_call_element* elem, const grpc_call_element_args* args) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   calld->call_combiner = args->call_combiner;
@@ -85,7 +85,7 @@ void client_authority_destroy_call_elem(
     grpc_closure* /*ignored*/) {}
 
 /* Constructor for channel_data */
-grpc_error* client_authority_init_channel_elem(
+grpc_error_handle client_authority_init_channel_elem(
     grpc_channel_element* elem, grpc_channel_element_args* args) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   const grpc_arg* default_authority_arg =

data/src/core/ext/filters/http/message_compress/message_compress_filter.cc

@@ -131,25 +131,25 @@ class CallData {
   bool SkipMessageCompression();
   void InitializeState(grpc_call_element* elem);
 
-  grpc_error* ProcessSendInitialMetadata(grpc_call_element* elem,
-                                         grpc_metadata_batch* initial_metadata);
+  grpc_error_handle ProcessSendInitialMetadata(
+      grpc_call_element* elem, grpc_metadata_batch* initial_metadata);
 
   // Methods for processing a send_message batch
-  static void StartSendMessageBatch(void* elem_arg, grpc_error* unused);
-  static void OnSendMessageNextDone(void* elem_arg, grpc_error* error);
-  grpc_error* PullSliceFromSendMessage();
+  static void StartSendMessageBatch(void* elem_arg, grpc_error_handle unused);
+  static void OnSendMessageNextDone(void* elem_arg, grpc_error_handle error);
+  grpc_error_handle PullSliceFromSendMessage();
   void ContinueReadingSendMessage(grpc_call_element* elem);
   void FinishSendMessage(grpc_call_element* elem);
   void SendMessageBatchContinue(grpc_call_element* elem);
   static void FailSendMessageBatchInCallCombiner(void* calld_arg,
-                                                 grpc_error* error);
+                                                 grpc_error_handle error);
 
-  static void SendMessageOnComplete(void* calld_arg, grpc_error* error);
+  static void SendMessageOnComplete(void* calld_arg, grpc_error_handle error);
 
   grpc_core::CallCombiner* call_combiner_;
   grpc_message_compression_algorithm message_compression_algorithm_ =
       GRPC_MESSAGE_COMPRESS_NONE;
-  grpc_error* cancel_error_ = GRPC_ERROR_NONE;
+  grpc_error_handle cancel_error_ = GRPC_ERROR_NONE;
   grpc_transport_stream_op_batch* send_message_batch_ = nullptr;
   bool seen_initial_metadata_ = false;
   /* Set to true, if the fields below are initialized. */
@@ -232,7 +232,7 @@ void CallData::InitializeState(grpc_call_element* elem) {
                     grpc_schedule_on_exec_ctx);
 }
 
-grpc_error* CallData::ProcessSendInitialMetadata(
+grpc_error_handle CallData::ProcessSendInitialMetadata(
     grpc_call_element* elem, grpc_metadata_batch* initial_metadata) {
   ChannelData* channeld = static_cast<ChannelData*>(elem->channel_data);
   // Find the compression algorithm.
@@ -246,7 +246,7 @@ grpc_error* CallData::ProcessSendInitialMetadata(
       grpc_compression_algorithm_to_stream_compression_algorithm(
           compression_algorithm);
   // Hint compression algorithm.
-  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_error_handle error = GRPC_ERROR_NONE;
   if (message_compression_algorithm_ != GRPC_MESSAGE_COMPRESS_NONE) {
     InitializeState(elem);
     error = grpc_metadata_batch_add_tail(
@@ -281,7 +281,7 @@ grpc_error* CallData::ProcessSendInitialMetadata(
   return error;
 }
 
-void CallData::SendMessageOnComplete(void* calld_arg, grpc_error* error) {
+void CallData::SendMessageOnComplete(void* calld_arg, grpc_error_handle error) {
   CallData* calld = static_cast<CallData*>(calld_arg);
   grpc_slice_buffer_reset_and_unref_internal(&calld->slices_);
   grpc_core::Closure::Run(DEBUG_LOCATION,
@@ -348,7 +348,7 @@ void CallData::FinishSendMessage(grpc_call_element* elem) {
 }
 
 void CallData::FailSendMessageBatchInCallCombiner(void* calld_arg,
-                                                  grpc_error* error) {
+                                                  grpc_error_handle error) {
   CallData* calld = static_cast<CallData*>(calld_arg);
   if (calld->send_message_batch_ != nullptr) {
     grpc_transport_stream_op_batch_finish_with_failure(
@@ -359,9 +359,9 @@ void CallData::FailSendMessageBatchInCallCombiner(void* calld_arg,
 }
 
 // Pulls a slice from the send_message byte stream and adds it to slices_.
-grpc_error* CallData::PullSliceFromSendMessage() {
+grpc_error_handle CallData::PullSliceFromSendMessage() {
   grpc_slice incoming_slice;
-  grpc_error* error =
+  grpc_error_handle error =
       send_message_batch_->payload->send_message.send_message->Pull(
           &incoming_slice);
   if (error == GRPC_ERROR_NONE) {
@@ -382,7 +382,7 @@ void CallData::ContinueReadingSendMessage(grpc_call_element* elem) {
   }
   while (send_message_batch_->payload->send_message.send_message->Next(
       ~static_cast<size_t>(0), &on_send_message_next_done_)) {
-    grpc_error* error = PullSliceFromSendMessage();
+    grpc_error_handle error = PullSliceFromSendMessage();
     if (error != GRPC_ERROR_NONE) {
       // Closure callback; does not take ownership of error.
       FailSendMessageBatchInCallCombiner(this, error);
@@ -398,7 +398,7 @@ void CallData::ContinueReadingSendMessage(grpc_call_element* elem) {
 }
 
 // Async callback for ByteStream::Next().
-void CallData::OnSendMessageNextDone(void* elem_arg, grpc_error* error) {
+void CallData::OnSendMessageNextDone(void* elem_arg, grpc_error_handle error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(elem_arg);
   CallData* calld = static_cast<CallData*>(elem->call_data);
   if (error != GRPC_ERROR_NONE) {
@@ -421,7 +421,8 @@ void CallData::OnSendMessageNextDone(void* elem_arg, grpc_error* error) {
   }
 }
 
-void CallData::StartSendMessageBatch(void* elem_arg, grpc_error* /*unused*/) {
+void CallData::StartSendMessageBatch(void* elem_arg,
+                                     grpc_error_handle /*unused*/) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(elem_arg);
   CallData* calld = static_cast<CallData*>(elem->call_data);
   if (calld->SkipMessageCompression()) {
@@ -458,7 +459,7 @@ void CallData::CompressStartTransportStreamOpBatch(
   // Handle send_initial_metadata.
   if (batch->send_initial_metadata) {
     GPR_ASSERT(!seen_initial_metadata_);
-    grpc_error* error = ProcessSendInitialMetadata(
+    grpc_error_handle error = ProcessSendInitialMetadata(
         elem, batch->payload->send_initial_metadata.send_initial_metadata);
     if (error != GRPC_ERROR_NONE) {
       grpc_transport_stream_op_batch_finish_with_failure(batch, error,
@@ -503,8 +504,8 @@ void CompressStartTransportStreamOpBatch(
 }
 
 /* Constructor for call_data */
-grpc_error* CompressInitCallElem(grpc_call_element* elem,
-                                 const grpc_call_element_args* args) {
+grpc_error_handle CompressInitCallElem(grpc_call_element* elem,
+                                       const grpc_call_element_args* args) {
   new (elem->call_data) CallData(elem, *args);
   return GRPC_ERROR_NONE;
 }
@@ -518,8 +519,8 @@ void CompressDestroyCallElem(grpc_call_element* elem,
 }
 
 /* Constructor for ChannelData */
-grpc_error* CompressInitChannelElem(grpc_channel_element* elem,
-                                    grpc_channel_element_args* args) {
+grpc_error_handle CompressInitChannelElem(grpc_channel_element* elem,
+                                          grpc_channel_element_args* args) {
   new (elem->channel_data) ChannelData(args);
   return GRPC_ERROR_NONE;
 }

data/src/core/ext/filters/http/message_compress/message_decompress_filter.cc

@@ -89,24 +89,24 @@ class CallData {
       grpc_call_element* elem, grpc_transport_stream_op_batch* batch);
 
  private:
-  static void OnRecvInitialMetadataReady(void* arg, grpc_error* error);
+  static void OnRecvInitialMetadataReady(void* arg, grpc_error_handle error);
 
   // Methods for processing a receive message event
   void MaybeResumeOnRecvMessageReady();
-  static void OnRecvMessageReady(void* arg, grpc_error* error);
-  static void OnRecvMessageNextDone(void* arg, grpc_error* error);
-  grpc_error* PullSliceFromRecvMessage();
+  static void OnRecvMessageReady(void* arg, grpc_error_handle error);
+  static void OnRecvMessageNextDone(void* arg, grpc_error_handle error);
+  grpc_error_handle PullSliceFromRecvMessage();
   void ContinueReadingRecvMessage();
   void FinishRecvMessage();
-  void ContinueRecvMessageReadyCallback(grpc_error* error);
+  void ContinueRecvMessageReadyCallback(grpc_error_handle error);
 
   // Methods for processing a recv_trailing_metadata event
   void MaybeResumeOnRecvTrailingMetadataReady();
-  static void OnRecvTrailingMetadataReady(void* arg, grpc_error* error);
+  static void OnRecvTrailingMetadataReady(void* arg, grpc_error_handle error);
 
   CallCombiner* call_combiner_;
   // Overall error for the call
-  grpc_error* error_ = GRPC_ERROR_NONE;
+  grpc_error_handle error_ = GRPC_ERROR_NONE;
   // Fields for handling recv_initial_metadata_ready callback
   grpc_closure on_recv_initial_metadata_ready_;
   grpc_closure* original_recv_initial_metadata_ready_ = nullptr;
@@ -130,7 +130,7 @@ class CallData {
   bool seen_recv_trailing_metadata_ready_ = false;
   grpc_closure on_recv_trailing_metadata_ready_;
   grpc_closure* original_recv_trailing_metadata_ready_ = nullptr;
-  grpc_error* on_recv_trailing_metadata_ready_error_ = GRPC_ERROR_NONE;
+  grpc_error_handle on_recv_trailing_metadata_ready_error_ = GRPC_ERROR_NONE;
 };
 
 grpc_message_compression_algorithm DecodeMessageCompressionAlgorithm(
@@ -149,7 +149,7 @@ grpc_message_compression_algorithm DecodeMessageCompressionAlgorithm(
   return algorithm;
 }
 
-void CallData::OnRecvInitialMetadataReady(void* arg, grpc_error* error) {
+void CallData::OnRecvInitialMetadataReady(void* arg, grpc_error_handle error) {
   CallData* calld = static_cast<CallData*>(arg);
   if (error == GRPC_ERROR_NONE) {
     grpc_linked_mdelem* grpc_encoding =
@@ -174,7 +174,7 @@ void CallData::MaybeResumeOnRecvMessageReady() {
   }
 }
 
-void CallData::OnRecvMessageReady(void* arg, grpc_error* error) {
+void CallData::OnRecvMessageReady(void* arg, grpc_error_handle error) {
   CallData* calld = static_cast<CallData*>(arg);
   if (error == GRPC_ERROR_NONE) {
     if (calld->original_recv_initial_metadata_ready_ != nullptr) {
@@ -218,7 +218,7 @@ void CallData::ContinueReadingRecvMessage() {
   while ((*recv_message_)
              ->Next((*recv_message_)->length() - recv_slices_.length,
                     &on_recv_message_next_done_)) {
-    grpc_error* error = PullSliceFromRecvMessage();
+    grpc_error_handle error = PullSliceFromRecvMessage();
     if (error != GRPC_ERROR_NONE) {
       return ContinueRecvMessageReadyCallback(error);
     }
@@ -229,16 +229,16 @@ void CallData::ContinueReadingRecvMessage() {
   }
 }
 
-grpc_error* CallData::PullSliceFromRecvMessage() {
+grpc_error_handle CallData::PullSliceFromRecvMessage() {
   grpc_slice incoming_slice;
-  grpc_error* error = (*recv_message_)->Pull(&incoming_slice);
+  grpc_error_handle error = (*recv_message_)->Pull(&incoming_slice);
   if (error == GRPC_ERROR_NONE) {
     grpc_slice_buffer_add(&recv_slices_, incoming_slice);
   }
   return error;
 }
 
-void CallData::OnRecvMessageNextDone(void* arg, grpc_error* error) {
+void CallData::OnRecvMessageNextDone(void* arg, grpc_error_handle error) {
   CallData* calld = static_cast<CallData*>(arg);
   if (error != GRPC_ERROR_NONE) {
     return calld->ContinueRecvMessageReadyCallback(GRPC_ERROR_REF(error));
@@ -283,7 +283,7 @@ void CallData::FinishRecvMessage() {
   ContinueRecvMessageReadyCallback(GRPC_ERROR_REF(error_));
 }
 
-void CallData::ContinueRecvMessageReadyCallback(grpc_error* error) {
+void CallData::ContinueRecvMessageReadyCallback(grpc_error_handle error) {
   MaybeResumeOnRecvTrailingMetadataReady();
   // The surface will clean up the receiving stream if there is an error.
   grpc_closure* closure = original_recv_message_ready_;
@@ -294,14 +294,14 @@ void CallData::ContinueRecvMessageReadyCallback(grpc_error* error) {
 void CallData::MaybeResumeOnRecvTrailingMetadataReady() {
   if (seen_recv_trailing_metadata_ready_) {
     seen_recv_trailing_metadata_ready_ = false;
-    grpc_error* error = on_recv_trailing_metadata_ready_error_;
+    grpc_error_handle error = on_recv_trailing_metadata_ready_error_;
     on_recv_trailing_metadata_ready_error_ = GRPC_ERROR_NONE;
     GRPC_CALL_COMBINER_START(call_combiner_, &on_recv_trailing_metadata_ready_,
                              error, "Continuing OnRecvTrailingMetadataReady");
   }
 }
 
-void CallData::OnRecvTrailingMetadataReady(void* arg, grpc_error* error) {
+void CallData::OnRecvTrailingMetadataReady(void* arg, grpc_error_handle error) {
   CallData* calld = static_cast<CallData*>(arg);
   if (calld->original_recv_initial_metadata_ready_ != nullptr ||
       calld->original_recv_message_ready_ != nullptr) {
@@ -356,8 +356,8 @@ void DecompressStartTransportStreamOpBatch(
   calld->DecompressStartTransportStreamOpBatch(elem, batch);
 }
 
-grpc_error* DecompressInitCallElem(grpc_call_element* elem,
-                                   const grpc_call_element_args* args) {
+grpc_error_handle DecompressInitCallElem(grpc_call_element* elem,
+                                         const grpc_call_element_args* args) {
   ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
   new (elem->call_data) CallData(*args, chand);
   return GRPC_ERROR_NONE;
@@ -370,8 +370,8 @@ void DecompressDestroyCallElem(grpc_call_element* elem,
   calld->~CallData();
 }
 
-grpc_error* DecompressInitChannelElem(grpc_channel_element* elem,
-                                      grpc_channel_element_args* args) {
+grpc_error_handle DecompressInitChannelElem(grpc_channel_element* elem,
+                                            grpc_channel_element_args* args) {
   ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
   new (chand) ChannelData(args);
   return GRPC_ERROR_NONE;

data/src/core/ext/filters/http/server/http_server_filter.cc

@@ -35,9 +35,11 @@
 #define EXPECTED_CONTENT_TYPE "application/grpc"
 #define EXPECTED_CONTENT_TYPE_LENGTH (sizeof(EXPECTED_CONTENT_TYPE) - 1)
 
-static void hs_recv_initial_metadata_ready(void* user_data, grpc_error* err);
-static void hs_recv_trailing_metadata_ready(void* user_data, grpc_error* err);
-static void hs_recv_message_ready(void* user_data, grpc_error* err);
+static void hs_recv_initial_metadata_ready(void* user_data,
+                                           grpc_error_handle err);
+static void hs_recv_trailing_metadata_ready(void* user_data,
+                                            grpc_error_handle err);
+static void hs_recv_message_ready(void* user_data, grpc_error_handle err);
 
 namespace {
 
@@ -74,7 +76,7 @@ struct call_data {
 
   // State for intercepting recv_initial_metadata.
   grpc_closure recv_initial_metadata_ready;
-  grpc_error* recv_initial_metadata_ready_error = GRPC_ERROR_NONE;
+  grpc_error_handle recv_initial_metadata_ready_error = GRPC_ERROR_NONE;
   grpc_closure* original_recv_initial_metadata_ready;
   grpc_metadata_batch* recv_initial_metadata = nullptr;
   uint32_t* recv_initial_metadata_flags;
@@ -89,7 +91,7 @@ struct call_data {
   // State for intercepting recv_trailing_metadata
   grpc_closure recv_trailing_metadata_ready;
   grpc_closure* original_recv_trailing_metadata_ready;
-  grpc_error* recv_trailing_metadata_ready_error;
+  grpc_error_handle recv_trailing_metadata_ready_error;
   bool seen_recv_trailing_metadata_ready = false;
 };
 
@@ -99,7 +101,7 @@ struct channel_data {
 
 }  // namespace
 
-static grpc_error* hs_filter_outgoing_metadata(grpc_metadata_batch* b) {
+static grpc_error_handle hs_filter_outgoing_metadata(grpc_metadata_batch* b) {
   if (b->idx.named.grpc_message != nullptr) {
     grpc_slice pct_encoded_msg = grpc_percent_encode_slice(
         GRPC_MDVALUE(b->idx.named.grpc_message->md),
@@ -114,8 +116,8 @@ static grpc_error* hs_filter_outgoing_metadata(grpc_metadata_batch* b) {
   return GRPC_ERROR_NONE;
 }
 
-static void hs_add_error(const char* error_name, grpc_error** cumulative,
-                         grpc_error* new_err) {
+static void hs_add_error(const char* error_name, grpc_error_handle* cumulative,
+                         grpc_error_handle new_err) {
   if (new_err == GRPC_ERROR_NONE) return;
   if (*cumulative == GRPC_ERROR_NONE) {
     *cumulative = GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_name);
@@ -149,10 +151,10 @@ static bool md_strict_equal(grpc_mdelem a, grpc_mdelem b_static) {
   }
 }
 
-static grpc_error* hs_filter_incoming_metadata(grpc_call_element* elem,
-                                               grpc_metadata_batch* b) {
+static grpc_error_handle hs_filter_incoming_metadata(grpc_call_element* elem,
+                                                     grpc_metadata_batch* b) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
-  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_error_handle error = GRPC_ERROR_NONE;
   static const char* error_name = "Failed processing incoming headers";
 
   if (b->idx.named.method != nullptr) {
@@ -330,7 +332,8 @@ static grpc_error* hs_filter_incoming_metadata(grpc_call_element* elem,
   return error;
 }
 
-static void hs_recv_initial_metadata_ready(void* user_data, grpc_error* err) {
+static void hs_recv_initial_metadata_ready(void* user_data,
+                                           grpc_error_handle err) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   calld->seen_recv_initial_metadata_ready = true;
@@ -367,7 +370,7 @@ static void hs_recv_initial_metadata_ready(void* user_data, grpc_error* err) {
                           calld->original_recv_initial_metadata_ready, err);
 }
 
-static void hs_recv_message_ready(void* user_data, grpc_error* err) {
+static void hs_recv_message_ready(void* user_data, grpc_error_handle err) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   calld->seen_recv_message_ready = true;
@@ -392,7 +395,8 @@ static void hs_recv_message_ready(void* user_data, grpc_error* err) {
   }
 }
 
-static void hs_recv_trailing_metadata_ready(void* user_data, grpc_error* err) {
+static void hs_recv_trailing_metadata_ready(void* user_data,
+                                            grpc_error_handle err) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   if (!calld->seen_recv_initial_metadata_ready) {
@@ -410,13 +414,13 @@ static void hs_recv_trailing_metadata_ready(void* user_data, grpc_error* err) {
                           calld->original_recv_trailing_metadata_ready, err);
 }
 
-static grpc_error* hs_mutate_op(grpc_call_element* elem,
-                                grpc_transport_stream_op_batch* op) {
+static grpc_error_handle hs_mutate_op(grpc_call_element* elem,
+                                      grpc_transport_stream_op_batch* op) {
   /* grab pointers to our data from the call element */
   call_data* calld = static_cast<call_data*>(elem->call_data);
 
   if (op->send_initial_metadata) {
-    grpc_error* error = GRPC_ERROR_NONE;
+    grpc_error_handle error = GRPC_ERROR_NONE;
     static const char* error_name = "Failed sending initial metadata";
     hs_add_error(
         error_name, &error,
@@ -463,7 +467,7 @@ static grpc_error* hs_mutate_op(grpc_call_element* elem,
   }
 
   if (op->send_trailing_metadata) {
-    grpc_error* error = hs_filter_outgoing_metadata(
+    grpc_error_handle error = hs_filter_outgoing_metadata(
         op->payload->send_trailing_metadata.send_trailing_metadata);
     if (error != GRPC_ERROR_NONE) return error;
   }
@@ -475,7 +479,7 @@ static void hs_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* op) {
   GPR_TIMER_SCOPE("hs_start_transport_stream_op_batch", 0);
   call_data* calld = static_cast<call_data*>(elem->call_data);
-  grpc_error* error = hs_mutate_op(elem, op);
+  grpc_error_handle error = hs_mutate_op(elem, op);
   if (error != GRPC_ERROR_NONE) {
     grpc_transport_stream_op_batch_finish_with_failure(op, error,
                                                        calld->call_combiner);
@@ -485,8 +489,8 @@ static void hs_start_transport_stream_op_batch(
 }
 
 /* Constructor for call_data */
-static grpc_error* hs_init_call_elem(grpc_call_element* elem,
-                                     const grpc_call_element_args* args) {
+static grpc_error_handle hs_init_call_elem(grpc_call_element* elem,
+                                           const grpc_call_element_args* args) {
   new (elem->call_data) call_data(elem, *args);
   return GRPC_ERROR_NONE;
 }
@@ -500,8 +504,8 @@ static void hs_destroy_call_elem(grpc_call_element* elem,
 }
 
 /* Constructor for channel_data */
-static grpc_error* hs_init_channel_elem(grpc_channel_element* elem,
-                                        grpc_channel_element_args* args) {
+static grpc_error_handle hs_init_channel_elem(grpc_channel_element* elem,
+                                              grpc_channel_element_args* args) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   GPR_ASSERT(!args->is_last);
   chand->surface_user_agent = grpc_channel_arg_get_bool(

data/src/core/ext/filters/max_age/max_age_filter.cc

@@ -206,7 +206,8 @@ static void decrease_call_count(channel_data* chand) {
   }
 }
 
-static void start_max_idle_timer_after_init(void* arg, grpc_error* /*error*/) {
+static void start_max_idle_timer_after_init(void* arg,
+                                            grpc_error_handle /*error*/) {
   channel_data* chand = static_cast<channel_data*>(arg);
   /* Decrease call_count. If there are no active calls at this time,
      max_idle_timer will start here. If the number of active calls is not 0,
@@ -258,7 +259,8 @@ class ConnectivityWatcher : public AsyncConnectivityStateWatcherInterface {
 
 }  // namespace grpc_core
 
-static void start_max_age_timer_after_init(void* arg, grpc_error* /*error*/) {
+static void start_max_age_timer_after_init(void* arg,
+                                           grpc_error_handle /*error*/) {
   channel_data* chand = static_cast<channel_data*>(arg);
   {
     grpc_core::MutexLock lock(&chand->max_age_timer_mu);
@@ -277,8 +279,8 @@ static void start_max_age_timer_after_init(void* arg, grpc_error* /*error*/) {
                            "max_age start_max_age_timer_after_init");
 }
 
-static void start_max_age_grace_timer_after_goaway_op(void* arg,
-                                                      grpc_error* /*error*/) {
+static void start_max_age_grace_timer_after_goaway_op(
+    void* arg, grpc_error_handle /*error*/) {
   channel_data* chand = static_cast<channel_data*>(arg);
   {
     grpc_core::MutexLock lock(&chand->max_age_timer_mu);
@@ -307,7 +309,7 @@ static void close_max_idle_channel(channel_data* chand) {
   elem->filter->start_transport_op(elem, op);
 }
 
-static void max_idle_timer_cb(void* arg, grpc_error* error) {
+static void max_idle_timer_cb(void* arg, grpc_error_handle error) {
   channel_data* chand = static_cast<channel_data*>(arg);
   if (error == GRPC_ERROR_NONE) {
     bool try_again = true;
@@ -351,7 +353,7 @@ static void max_idle_timer_cb(void* arg, grpc_error* error) {
   GRPC_CHANNEL_STACK_UNREF(chand->channel_stack, "max_age max_idle_timer");
 }
 
-static void close_max_age_channel(void* arg, grpc_error* error) {
+static void close_max_age_channel(void* arg, grpc_error_handle error) {
   channel_data* chand = static_cast<channel_data*>(arg);
   {
     grpc_core::MutexLock lock(&chand->max_age_timer_mu);
@@ -374,7 +376,7 @@ static void close_max_age_channel(void* arg, grpc_error* error) {
   GRPC_CHANNEL_STACK_UNREF(chand->channel_stack, "max_age max_age_timer");
 }
 
-static void force_close_max_age_channel(void* arg, grpc_error* error) {
+static void force_close_max_age_channel(void* arg, grpc_error_handle error) {
   channel_data* chand = static_cast<channel_data*>(arg);
   {
     grpc_core::MutexLock lock(&chand->max_age_timer_mu);
@@ -412,7 +414,7 @@ add_random_max_connection_age_jitter_and_convert_to_grpc_millis(int value) {
 }
 
 /* Constructor for call_data. */
-static grpc_error* max_age_init_call_elem(
+static grpc_error_handle max_age_init_call_elem(
     grpc_call_element* elem, const grpc_call_element_args* /*args*/) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   increase_call_count(chand);
@@ -428,8 +430,8 @@ static void max_age_destroy_call_elem(
 }
 
 /* Constructor for channel_data. */
-static grpc_error* max_age_init_channel_elem(grpc_channel_element* elem,
-                                             grpc_channel_element_args* args) {
+static grpc_error_handle max_age_init_channel_elem(
+    grpc_channel_element* elem, grpc_channel_element_args* args) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   new (chand) channel_data();
   chand->channel_stack = args->channel_stack;