grpc 1.37.1 → 1.40.0.pre1

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

@@ -32,7 +32,7 @@ namespace grpc_core {
 
 RefCountedPtr<ServiceConfig> ServiceConfig::Create(
     const grpc_channel_args* args, absl::string_view json_string,
-    grpc_error** error) {
+    grpc_error_handle* error) {
   GPR_DEBUG_ASSERT(error != nullptr);
   Json json = Json::Parse(json_string, error);
   if (*error != GRPC_ERROR_NONE) return nullptr;
@@ -42,7 +42,7 @@ RefCountedPtr<ServiceConfig> ServiceConfig::Create(
 
 ServiceConfig::ServiceConfig(const grpc_channel_args* args,
                              std::string json_string, Json json,
-                             grpc_error** error)
+                             grpc_error_handle* error)
     : json_string_(std::move(json_string)), json_(std::move(json)) {
   GPR_DEBUG_ASSERT(error != nullptr);
   if (json_.type() != Json::Type::OBJECT) {
@@ -50,12 +50,12 @@ ServiceConfig::ServiceConfig(const grpc_channel_args* args,
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("JSON value is not an object");
     return;
   }
-  std::vector<grpc_error*> error_list;
-  grpc_error* global_error = GRPC_ERROR_NONE;
+  std::vector<grpc_error_handle> error_list;
+  grpc_error_handle global_error = GRPC_ERROR_NONE;
   parsed_global_configs_ =
       ServiceConfigParser::ParseGlobalParameters(args, json_, &global_error);
   if (global_error != GRPC_ERROR_NONE) error_list.push_back(global_error);
-  grpc_error* local_error = ParsePerMethodParams(args);
+  grpc_error_handle local_error = ParsePerMethodParams(args);
   if (local_error != GRPC_ERROR_NONE) error_list.push_back(local_error);
   if (!error_list.empty()) {
     *error = GRPC_ERROR_CREATE_FROM_VECTOR("Service config parsing error",
@@ -69,13 +69,13 @@ ServiceConfig::~ServiceConfig() {
   }
 }
 
-grpc_error* ServiceConfig::ParseJsonMethodConfig(const grpc_channel_args* args,
-                                                 const Json& json) {
-  std::vector<grpc_error*> error_list;
+grpc_error_handle ServiceConfig::ParseJsonMethodConfig(
+    const grpc_channel_args* args, const Json& json) {
+  std::vector<grpc_error_handle> error_list;
   // Parse method config with each registered parser.
   auto parsed_configs =
       absl::make_unique<ServiceConfigParser::ParsedConfigVector>();
-  grpc_error* parser_error = GRPC_ERROR_NONE;
+  grpc_error_handle parser_error = GRPC_ERROR_NONE;
   *parsed_configs =
       ServiceConfigParser::ParsePerMethodParameters(args, json, &parser_error);
   if (parser_error != GRPC_ERROR_NONE) {
@@ -94,7 +94,7 @@ grpc_error* ServiceConfig::ParseJsonMethodConfig(const grpc_channel_args* args,
     }
     const Json::Array& name_array = it->second.array_value();
     for (const Json& name : name_array) {
-      grpc_error* parse_error = GRPC_ERROR_NONE;
+      grpc_error_handle parse_error = GRPC_ERROR_NONE;
       std::string path = ParseJsonMethodName(name, &parse_error);
       if (parse_error != GRPC_ERROR_NONE) {
         error_list.push_back(parse_error);
@@ -130,8 +130,9 @@ grpc_error* ServiceConfig::ParseJsonMethodConfig(const grpc_channel_args* args,
   return GRPC_ERROR_CREATE_FROM_VECTOR("methodConfig", &error_list);
 }
 
-grpc_error* ServiceConfig::ParsePerMethodParams(const grpc_channel_args* args) {
-  std::vector<grpc_error*> error_list;
+grpc_error_handle ServiceConfig::ParsePerMethodParams(
+    const grpc_channel_args* args) {
+  std::vector<grpc_error_handle> error_list;
   auto it = json_.object_value().find("methodConfig");
   if (it != json_.object_value().end()) {
     if (it->second.type() != Json::Type::ARRAY) {
@@ -144,7 +145,7 @@ grpc_error* ServiceConfig::ParsePerMethodParams(const grpc_channel_args* args) {
             "field:methodConfig error:not of type Object"));
         continue;
       }
-      grpc_error* error = ParseJsonMethodConfig(args, method_config);
+      grpc_error_handle error = ParseJsonMethodConfig(args, method_config);
       if (error != GRPC_ERROR_NONE) {
         error_list.push_back(error);
       }
@@ -154,7 +155,7 @@ grpc_error* ServiceConfig::ParsePerMethodParams(const grpc_channel_args* args) {
 }
 
 std::string ServiceConfig::ParseJsonMethodName(const Json& json,
-                                               grpc_error** error) {
+                                               grpc_error_handle* error) {
   if (json.type() != Json::Type::OBJECT) {
     *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "field:name error:type is not object");

data/src/core/ext/filters/client_channel/service_config.h

@@ -67,10 +67,10 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
   /// Returns null on parse error.
   static RefCountedPtr<ServiceConfig> Create(const grpc_channel_args* args,
                                              absl::string_view json_string,
-                                             grpc_error** error);
+                                             grpc_error_handle* error);
 
   ServiceConfig(const grpc_channel_args* args, std::string json_string,
-                Json json, grpc_error** error);
+                Json json, grpc_error_handle* error);
   ~ServiceConfig() override;
 
   const std::string& json_string() const { return json_string_; }
@@ -91,13 +91,14 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
 
  private:
   // Helper functions for parsing the method configs.
-  grpc_error* ParsePerMethodParams(const grpc_channel_args* args);
-  grpc_error* ParseJsonMethodConfig(const grpc_channel_args* args,
-                                    const Json& json);
+  grpc_error_handle ParsePerMethodParams(const grpc_channel_args* args);
+  grpc_error_handle ParseJsonMethodConfig(const grpc_channel_args* args,
+                                          const Json& json);
 
   // Returns a path string for the JSON name object specified by json.
   // Sets *error on error.
-  static std::string ParseJsonMethodName(const Json& json, grpc_error** error);
+  static std::string ParseJsonMethodName(const Json& json,
+                                         grpc_error_handle* error);
 
   std::string json_string_;
   Json json_;

data/src/core/ext/filters/client_channel/service_config_call_data.h

@@ -23,6 +23,7 @@
 
 #include "absl/strings/string_view.h"
 
+#include "src/core/ext/filters/client_channel/config_selector.h"
 #include "src/core/ext/filters/client_channel/service_config.h"
 #include "src/core/ext/filters/client_channel/service_config_parser.h"
 #include "src/core/lib/channel/context.h"
@@ -39,11 +40,13 @@ class ServiceConfigCallData {
   ServiceConfigCallData(
       RefCountedPtr<ServiceConfig> service_config,
       const ServiceConfigParser::ParsedConfigVector* method_configs,
-      std::map<const char*, absl::string_view> call_attributes,
+      ConfigSelector::CallAttributes call_attributes,
+      ConfigSelector::CallDispatchController* call_dispatch_controller,
       grpc_call_context_element* call_context)
       : service_config_(std::move(service_config)),
         method_configs_(method_configs),
-        call_attributes_(std::move(call_attributes)) {
+        call_attributes_(std::move(call_attributes)),
+        call_dispatch_controller_(call_dispatch_controller) {
     call_context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value = this;
     call_context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].destroy = Destroy;
   }
@@ -53,7 +56,7 @@ class ServiceConfigCallData {
       const ServiceConfigParser::ParsedConfigVector* method_configs,
       grpc_call_context_element* call_context)
       : ServiceConfigCallData(std::move(service_config), method_configs, {},
-                              call_context) {}
+                              nullptr, call_context) {}
 
   ServiceConfig* service_config() { return service_config_.get(); }
 
@@ -70,15 +73,52 @@ class ServiceConfigCallData {
     return call_attributes_;
   }
 
+  ConfigSelector::CallDispatchController* call_dispatch_controller() {
+    return &call_dispatch_controller_;
+  }
+
  private:
+  // A wrapper for the CallDispatchController returned by the ConfigSelector.
+  // Handles the case where the ConfigSelector doees not return any
+  // CallDispatchController.
+  // Also ensures that we call Commit() at most once, which allows the
+  // client channel code to call Commit() when the call is complete in case
+  // it wasn't called earlier, without needing to know whether or not it was.
+  class SingleCommitCallDispatchController
+      : public ConfigSelector::CallDispatchController {
+   public:
+    explicit SingleCommitCallDispatchController(
+        ConfigSelector::CallDispatchController* call_dispatch_controller)
+        : call_dispatch_controller_(call_dispatch_controller) {}
+
+    bool ShouldRetry() override {
+      if (call_dispatch_controller_ != nullptr) {
+        return call_dispatch_controller_->ShouldRetry();
+      }
+      return true;
+    }
+
+    void Commit() override {
+      if (call_dispatch_controller_ != nullptr && !commit_called_) {
+        call_dispatch_controller_->Commit();
+        commit_called_ = true;
+      }
+    }
+
+   private:
+    ConfigSelector::CallDispatchController* call_dispatch_controller_;
+    bool commit_called_ = false;
+  };
+
   static void Destroy(void* ptr) {
     ServiceConfigCallData* self = static_cast<ServiceConfigCallData*>(ptr);
     self->~ServiceConfigCallData();
   }
 
   RefCountedPtr<ServiceConfig> service_config_;
-  const ServiceConfigParser::ParsedConfigVector* method_configs_ = nullptr;
-  std::map<const char*, absl::string_view> call_attributes_;
+  const ServiceConfigParser::ParsedConfigVector* method_configs_;
+  ConfigSelector::CallAttributes call_attributes_;
+  SingleCommitCallDispatchController call_dispatch_controller_;
 };
 
 }  // namespace grpc_core

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

@@ -36,13 +36,14 @@ class ServiceConfigChannelArgChannelData {
     const char* service_config_str = grpc_channel_args_find_string(
         args->channel_args, GRPC_ARG_SERVICE_CONFIG);
     if (service_config_str != nullptr) {
-      grpc_error* service_config_error = GRPC_ERROR_NONE;
+      grpc_error_handle service_config_error = GRPC_ERROR_NONE;
       auto service_config = ServiceConfig::Create(
           args->channel_args, service_config_str, &service_config_error);
       if (service_config_error == GRPC_ERROR_NONE) {
         service_config_ = std::move(service_config);
       } else {
-        gpr_log(GPR_ERROR, "%s", grpc_error_string(service_config_error));
+        gpr_log(GPR_ERROR, "%s",
+                grpc_error_std_string(service_config_error).c_str());
       }
       GRPC_ERROR_UNREF(service_config_error);
     }
@@ -73,7 +74,7 @@ class ServiceConfigChannelArgCallData {
   }
 };
 
-grpc_error* ServiceConfigChannelArgInitCallElem(
+grpc_error_handle ServiceConfigChannelArgInitCallElem(
     grpc_call_element* elem, const grpc_call_element_args* args) {
   ServiceConfigChannelArgCallData* calld =
       static_cast<ServiceConfigChannelArgCallData*>(elem->call_data);
@@ -89,7 +90,7 @@ void ServiceConfigChannelArgDestroyCallElem(
   calld->~ServiceConfigChannelArgCallData();
 }
 
-grpc_error* ServiceConfigChannelArgInitChannelElem(
+grpc_error_handle ServiceConfigChannelArgInitChannelElem(
     grpc_channel_element* elem, grpc_channel_element_args* args) {
   ServiceConfigChannelArgChannelData* chand =
       static_cast<ServiceConfigChannelArgChannelData*>(elem->channel_data);

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

@@ -47,11 +47,11 @@ size_t ServiceConfigParser::RegisterParser(std::unique_ptr<Parser> parser) {
 ServiceConfigParser::ParsedConfigVector
 ServiceConfigParser::ParseGlobalParameters(const grpc_channel_args* args,
                                            const Json& json,
-                                           grpc_error** error) {
+                                           grpc_error_handle* error) {
   ParsedConfigVector parsed_global_configs;
-  std::vector<grpc_error*> error_list;
+  std::vector<grpc_error_handle> error_list;
   for (size_t i = 0; i < g_registered_parsers->size(); i++) {
-    grpc_error* parser_error = GRPC_ERROR_NONE;
+    grpc_error_handle parser_error = GRPC_ERROR_NONE;
     auto parsed_config = (*g_registered_parsers)[i]->ParseGlobalParams(
         args, json, &parser_error);
     if (parser_error != GRPC_ERROR_NONE) {
@@ -68,11 +68,11 @@ ServiceConfigParser::ParseGlobalParameters(const grpc_channel_args* args,
 ServiceConfigParser::ParsedConfigVector
 ServiceConfigParser::ParsePerMethodParameters(const grpc_channel_args* args,
                                               const Json& json,
-                                              grpc_error** error) {
+                                              grpc_error_handle* error) {
   ParsedConfigVector parsed_method_configs;
-  std::vector<grpc_error*> error_list;
+  std::vector<grpc_error_handle> error_list;
   for (size_t i = 0; i < g_registered_parsers->size(); i++) {
-    grpc_error* parser_error = GRPC_ERROR_NONE;
+    grpc_error_handle parser_error = GRPC_ERROR_NONE;
     auto parsed_config = (*g_registered_parsers)[i]->ParsePerMethodParams(
         args, json, &parser_error);
     if (parser_error != GRPC_ERROR_NONE) {

data/src/core/ext/filters/client_channel/service_config_parser.h

@@ -47,7 +47,8 @@ class ServiceConfigParser {
     virtual ~Parser() = default;
 
     virtual std::unique_ptr<ParsedConfig> ParseGlobalParams(
-        const grpc_channel_args*, const Json& /* json */, grpc_error** error) {
+        const grpc_channel_args*, const Json& /* json */,
+        grpc_error_handle* error) {
       // Avoid unused parameter warning on debug-only parameter
       (void)error;
       GPR_DEBUG_ASSERT(error != nullptr);
@@ -55,7 +56,8 @@ class ServiceConfigParser {
     }
 
     virtual std::unique_ptr<ParsedConfig> ParsePerMethodParams(
-        const grpc_channel_args*, const Json& /* json */, grpc_error** error) {
+        const grpc_channel_args*, const Json& /* json */,
+        grpc_error_handle* error) {
       // Avoid unused parameter warning on debug-only parameter
       (void)error;
       GPR_DEBUG_ASSERT(error != nullptr);
@@ -81,10 +83,11 @@ class ServiceConfigParser {
 
   static ParsedConfigVector ParseGlobalParameters(const grpc_channel_args* args,
                                                   const Json& json,
-                                                  grpc_error** error);
+                                                  grpc_error_handle* error);
 
   static ParsedConfigVector ParsePerMethodParameters(
-      const grpc_channel_args* args, const Json& json, grpc_error** error);
+      const grpc_channel_args* args, const Json& json,
+      grpc_error_handle* error);
 };
 
 }  // namespace grpc_core

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

@@ -36,6 +36,8 @@
 #include "src/core/ext/filters/client_channel/proxy_mapper_registry.h"
 #include "src/core/ext/filters/client_channel/service_config.h"
 #include "src/core/ext/filters/client_channel/subchannel_pool_interface.h"
+#include "src/core/lib/address_utils/parse_address.h"
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/connected_channel.h"
@@ -45,8 +47,6 @@
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/iomgr/parse_address.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/channel.h"
@@ -131,7 +131,7 @@ size_t ConnectedSubchannel::GetInitialCallSizeEstimate() const {
 //
 
 RefCountedPtr<SubchannelCall> SubchannelCall::Create(Args args,
-                                                     grpc_error** error) {
+                                                     grpc_error_handle* error) {
   const size_t allocation_size =
       args.connected_subchannel->GetInitialCallSizeEstimate();
   Arena* arena = args.arena;
@@ -139,7 +139,7 @@ RefCountedPtr<SubchannelCall> SubchannelCall::Create(Args args,
       arena->Alloc(allocation_size)) SubchannelCall(std::move(args), error));
 }
 
-SubchannelCall::SubchannelCall(Args args, grpc_error** error)
+SubchannelCall::SubchannelCall(Args args, grpc_error_handle* error)
     : connected_subchannel_(std::move(args.connected_subchannel)),
       deadline_(args.deadline) {
   grpc_call_stack* callstk = SUBCHANNEL_CALL_TO_CALL_STACK(this);
@@ -156,8 +156,7 @@ SubchannelCall::SubchannelCall(Args args, grpc_error** error)
   *error = grpc_call_stack_init(connected_subchannel_->channel_stack(), 1,
                                 SubchannelCall::Destroy, this, &call_args);
   if (GPR_UNLIKELY(*error != GRPC_ERROR_NONE)) {
-    const char* error_string = grpc_error_string(*error);
-    gpr_log(GPR_ERROR, "error: %s", error_string);
+    gpr_log(GPR_ERROR, "error: %s", grpc_error_std_string(*error).c_str());
     return;
   }
   grpc_call_stack_set_pollset_or_pollset_set(callstk, args.pollent);
@@ -207,7 +206,7 @@ void SubchannelCall::Unref(const DebugLocation& /*location*/,
   GRPC_CALL_STACK_UNREF(SUBCHANNEL_CALL_TO_CALL_STACK(this), reason);
 }
 
-void SubchannelCall::Destroy(void* arg, grpc_error* /*error*/) {
+void SubchannelCall::Destroy(void* arg, grpc_error_handle /*error*/) {
   GPR_TIMER_SCOPE("subchannel_call_destroy", 0);
   SubchannelCall* self = static_cast<SubchannelCall*>(arg);
   // Keep some members before destroying the subchannel call.
@@ -252,7 +251,7 @@ namespace {
 
 // Sets *status based on the rest of the parameters.
 void GetCallStatus(grpc_status_code* status, grpc_millis deadline,
-                   grpc_metadata_batch* md_batch, grpc_error* error) {
+                   grpc_metadata_batch* md_batch, grpc_error_handle error) {
   if (error != GRPC_ERROR_NONE) {
     grpc_error_get_status(error, deadline, status, nullptr, nullptr, nullptr);
   } else {
@@ -268,7 +267,8 @@ void GetCallStatus(grpc_status_code* status, grpc_millis deadline,
 
 }  // namespace
 
-void SubchannelCall::RecvTrailingMetadataReady(void* arg, grpc_error* error) {
+void SubchannelCall::RecvTrailingMetadataReady(void* arg,
+                                               grpc_error_handle error) {
   SubchannelCall* call = static_cast<SubchannelCall*>(arg);
   GPR_ASSERT(call->recv_trailing_metadata_ != nullptr);
   grpc_status_code status = GRPC_STATUS_OK;
@@ -375,7 +375,7 @@ class Subchannel::AsyncWatcherNotifierLocked {
     ExecCtx::Run(DEBUG_LOCATION,
                  GRPC_CLOSURE_INIT(
                      &closure_,
-                     [](void* arg, grpc_error* /*error*/) {
+                     [](void* arg, grpc_error_handle /*error*/) {
                        auto* self =
                            static_cast<AsyncWatcherNotifierLocked*>(arg);
                        self->watcher_->OnConnectivityStateChange();
@@ -963,7 +963,7 @@ void Subchannel::MaybeStartConnectingLocked() {
   }
 }
 
-void Subchannel::OnRetryAlarm(void* arg, grpc_error* error) {
+void Subchannel::OnRetryAlarm(void* arg, grpc_error_handle error) {
   WeakRefCountedPtr<Subchannel> c(static_cast<Subchannel*>(arg));
   MutexLock lock(&c->mu_);
   c->have_retry_alarm_ = false;
@@ -998,7 +998,7 @@ void Subchannel::ContinueConnectingLocked() {
   connector_->Connect(args, &connecting_result_, &on_connecting_finished_);
 }
 
-void Subchannel::OnConnectingFinished(void* arg, grpc_error* error) {
+void Subchannel::OnConnectingFinished(void* arg, grpc_error_handle error) {
   WeakRefCountedPtr<Subchannel> c(static_cast<Subchannel*>(arg));
   const grpc_channel_args* delete_channel_args =
       c->connecting_result_.channel_args;
@@ -1009,7 +1009,8 @@ void Subchannel::OnConnectingFinished(void* arg, grpc_error* error) {
         c->PublishTransportLocked()) {
       // Do nothing, transport was published.
     } else if (!c->disconnected_) {
-      gpr_log(GPR_INFO, "Connect failed: %s", grpc_error_string(error));
+      gpr_log(GPR_INFO, "Connect failed: %s",
+              grpc_error_std_string(error).c_str());
       c->SetConnectivityStateLocked(GRPC_CHANNEL_TRANSIENT_FAILURE,
                                     grpc_error_to_absl_status(error));
     }
@@ -1020,7 +1021,7 @@ void Subchannel::OnConnectingFinished(void* arg, grpc_error* error) {
 
 namespace {
 
-void ConnectionDestroy(void* arg, grpc_error* /*error*/) {
+void ConnectionDestroy(void* arg, grpc_error_handle /*error*/) {
   grpc_channel_stack* stk = static_cast<grpc_channel_stack*>(arg);
   grpc_channel_stack_destroy(stk);
   gpr_free(stk);
@@ -1040,13 +1041,13 @@ bool Subchannel::PublishTransportLocked() {
     return false;
   }
   grpc_channel_stack* stk;
-  grpc_error* error = grpc_channel_stack_builder_finish(
+  grpc_error_handle error = grpc_channel_stack_builder_finish(
       builder, 0, 1, ConnectionDestroy, nullptr,
       reinterpret_cast<void**>(&stk));
   if (error != GRPC_ERROR_NONE) {
     grpc_transport_destroy(connecting_result_.transport);
     gpr_log(GPR_ERROR, "error initializing subchannel stack: %s",
-            grpc_error_string(error));
+            grpc_error_std_string(error).c_str());
     GRPC_ERROR_UNREF(error);
     return false;
   }

data/src/core/ext/filters/client_channel/subchannel.h

@@ -87,7 +87,8 @@ class SubchannelCall {
     grpc_call_context_element* context;
     CallCombiner* call_combiner;
   };
-  static RefCountedPtr<SubchannelCall> Create(Args args, grpc_error** error);
+  static RefCountedPtr<SubchannelCall> Create(Args args,
+                                              grpc_error_handle* error);
 
   // Continues processing a transport stream op batch.
   void StartTransportStreamOpBatch(grpc_transport_stream_op_batch* batch);
@@ -113,20 +114,20 @@ class SubchannelCall {
   template <typename T>
   friend class RefCountedPtr;
 
-  SubchannelCall(Args args, grpc_error** error);
+  SubchannelCall(Args args, grpc_error_handle* error);
 
   // If channelz is enabled, intercepts recv_trailing so that we may check the
   // status and associate it to a subchannel.
   void MaybeInterceptRecvTrailingMetadata(
       grpc_transport_stream_op_batch* batch);
 
-  static void RecvTrailingMetadataReady(void* arg, grpc_error* error);
+  static void RecvTrailingMetadataReady(void* arg, grpc_error_handle error);
 
   // Interface of RefCounted<>.
   void IncrementRefCount();
   void IncrementRefCount(const DebugLocation& location, const char* reason);
 
-  static void Destroy(void* arg, grpc_error* error);
+  static void Destroy(void* arg, grpc_error_handle error);
 
   RefCountedPtr<ConnectedSubchannel> connected_subchannel_;
   grpc_closure* after_call_stack_destroy_ = nullptr;
@@ -340,10 +341,10 @@ class Subchannel : public DualRefCounted<Subchannel> {
 
   // Methods for connection.
   void MaybeStartConnectingLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-  static void OnRetryAlarm(void* arg, grpc_error* error)
+  static void OnRetryAlarm(void* arg, grpc_error_handle error)
       ABSL_LOCKS_EXCLUDED(mu_);
   void ContinueConnectingLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-  static void OnConnectingFinished(void* arg, grpc_error* error)
+  static void OnConnectingFinished(void* arg, grpc_error_handle error)
       ABSL_LOCKS_EXCLUDED(mu_);
   bool PublishTransportLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);