grpc 1.8.7 → 1.9.0.pre1

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

@@ -46,14 +46,13 @@ static void grpc_proxy_mapper_list_register(grpc_proxy_mapper_list* list,
   ++list->num_mappers;
 }
 
-static bool grpc_proxy_mapper_list_map_name(grpc_exec_ctx* exec_ctx,
-                                            grpc_proxy_mapper_list* list,
+static bool grpc_proxy_mapper_list_map_name(grpc_proxy_mapper_list* list,
                                             const char* server_uri,
                                             const grpc_channel_args* args,
                                             char** name_to_resolve,
                                             grpc_channel_args** new_args) {
   for (size_t i = 0; i < list->num_mappers; ++i) {
-    if (grpc_proxy_mapper_map_name(exec_ctx, list->list[i], server_uri, args,
+    if (grpc_proxy_mapper_map_name(list->list[i], server_uri, args,
                                    name_to_resolve, new_args)) {
       return true;
     }
@@ -62,12 +61,12 @@ static bool grpc_proxy_mapper_list_map_name(grpc_exec_ctx* exec_ctx,
 }
 
 static bool grpc_proxy_mapper_list_map_address(
-    grpc_exec_ctx* exec_ctx, grpc_proxy_mapper_list* list,
-    const grpc_resolved_address* address, const grpc_channel_args* args,
-    grpc_resolved_address** new_address, grpc_channel_args** new_args) {
+    grpc_proxy_mapper_list* list, const grpc_resolved_address* address,
+    const grpc_channel_args* args, grpc_resolved_address** new_address,
+    grpc_channel_args** new_args) {
   for (size_t i = 0; i < list->num_mappers; ++i) {
-    if (grpc_proxy_mapper_map_address(exec_ctx, list->list[i], address, args,
-                                      new_address, new_args)) {
+    if (grpc_proxy_mapper_map_address(list->list[i], address, args, new_address,
+                                      new_args)) {
       return true;
     }
   }
@@ -105,20 +104,17 @@ void grpc_proxy_mapper_register(bool at_start, grpc_proxy_mapper* mapper) {
   grpc_proxy_mapper_list_register(&g_proxy_mapper_list, at_start, mapper);
 }
 
-bool grpc_proxy_mappers_map_name(grpc_exec_ctx* exec_ctx,
-                                 const char* server_uri,
+bool grpc_proxy_mappers_map_name(const char* server_uri,
                                  const grpc_channel_args* args,
                                  char** name_to_resolve,
                                  grpc_channel_args** new_args) {
-  return grpc_proxy_mapper_list_map_name(exec_ctx, &g_proxy_mapper_list,
-                                         server_uri, args, name_to_resolve,
-                                         new_args);
+  return grpc_proxy_mapper_list_map_name(&g_proxy_mapper_list, server_uri, args,
+                                         name_to_resolve, new_args);
 }
-bool grpc_proxy_mappers_map_address(grpc_exec_ctx* exec_ctx,
-                                    const grpc_resolved_address* address,
+bool grpc_proxy_mappers_map_address(const grpc_resolved_address* address,
                                     const grpc_channel_args* args,
                                     grpc_resolved_address** new_address,
                                     grpc_channel_args** new_args) {
-  return grpc_proxy_mapper_list_map_address(
-      exec_ctx, &g_proxy_mapper_list, address, args, new_address, new_args);
+  return grpc_proxy_mapper_list_map_address(&g_proxy_mapper_list, address, args,
+                                            new_address, new_args);
 }

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

@@ -21,10 +21,6 @@
 
 #include "src/core/ext/filters/client_channel/proxy_mapper.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 void grpc_proxy_mapper_registry_init();
 void grpc_proxy_mapper_registry_shutdown();
 
@@ -33,20 +29,14 @@ void grpc_proxy_mapper_registry_shutdown();
 /// the list.  Otherwise, it will be added to the end.
 void grpc_proxy_mapper_register(bool at_start, grpc_proxy_mapper* mapper);
 
-bool grpc_proxy_mappers_map_name(grpc_exec_ctx* exec_ctx,
-                                 const char* server_uri,
+bool grpc_proxy_mappers_map_name(const char* server_uri,
                                  const grpc_channel_args* args,
                                  char** name_to_resolve,
                                  grpc_channel_args** new_args);
 
-bool grpc_proxy_mappers_map_address(grpc_exec_ctx* exec_ctx,
-                                    const grpc_resolved_address* address,
+bool grpc_proxy_mappers_map_address(const grpc_resolved_address* address,
                                     const grpc_channel_args* args,
                                     grpc_resolved_address** new_address,
                                     grpc_channel_args** new_args);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_PROXY_MAPPER_REGISTRY_H */

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

@@ -46,8 +46,8 @@ void grpc_resolver_ref(grpc_resolver* resolver) {
 }
 
 #ifndef NDEBUG
-void grpc_resolver_unref(grpc_exec_ctx* exec_ctx, grpc_resolver* resolver,
-                         const char* file, int line, const char* reason) {
+void grpc_resolver_unref(grpc_resolver* resolver, const char* file, int line,
+                         const char* reason) {
   if (grpc_trace_resolver_refcount.enabled()) {
     gpr_atm old_refs = gpr_atm_no_barrier_load(&resolver->refs.count);
     gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
@@ -55,27 +55,25 @@ void grpc_resolver_unref(grpc_exec_ctx* exec_ctx, grpc_resolver* resolver,
             old_refs, old_refs - 1, reason);
   }
 #else
-void grpc_resolver_unref(grpc_exec_ctx* exec_ctx, grpc_resolver* resolver) {
+void grpc_resolver_unref(grpc_resolver* resolver) {
 #endif
   if (gpr_unref(&resolver->refs)) {
     grpc_combiner* combiner = resolver->combiner;
-    resolver->vtable->destroy(exec_ctx, resolver);
-    GRPC_COMBINER_UNREF(exec_ctx, combiner, "resolver");
+    resolver->vtable->destroy(resolver);
+    GRPC_COMBINER_UNREF(combiner, "resolver");
   }
 }
 
-void grpc_resolver_shutdown_locked(grpc_exec_ctx* exec_ctx,
-                                   grpc_resolver* resolver) {
-  resolver->vtable->shutdown_locked(exec_ctx, resolver);
+void grpc_resolver_shutdown_locked(grpc_resolver* resolver) {
+  resolver->vtable->shutdown_locked(resolver);
 }
 
-void grpc_resolver_channel_saw_error_locked(grpc_exec_ctx* exec_ctx,
-                                            grpc_resolver* resolver) {
-  resolver->vtable->channel_saw_error_locked(exec_ctx, resolver);
+void grpc_resolver_channel_saw_error_locked(grpc_resolver* resolver) {
+  resolver->vtable->channel_saw_error_locked(resolver);
 }
 
-void grpc_resolver_next_locked(grpc_exec_ctx* exec_ctx, grpc_resolver* resolver,
+void grpc_resolver_next_locked(grpc_resolver* resolver,
                                grpc_channel_args** result,
                                grpc_closure* on_complete) {
-  resolver->vtable->next_locked(exec_ctx, resolver, result, on_complete);
+  resolver->vtable->next_locked(resolver, result, on_complete);
 }

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

@@ -22,10 +22,6 @@
 #include "src/core/ext/filters/client_channel/subchannel.h"
 #include "src/core/lib/iomgr/iomgr.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 typedef struct grpc_resolver grpc_resolver;
 typedef struct grpc_resolver_vtable grpc_resolver_vtable;
 
@@ -39,43 +35,40 @@ struct grpc_resolver {
 };
 
 struct grpc_resolver_vtable {
-  void (*destroy)(grpc_exec_ctx* exec_ctx, grpc_resolver* resolver);
-  void (*shutdown_locked)(grpc_exec_ctx* exec_ctx, grpc_resolver* resolver);
-  void (*channel_saw_error_locked)(grpc_exec_ctx* exec_ctx,
-                                   grpc_resolver* resolver);
-  void (*next_locked)(grpc_exec_ctx* exec_ctx, grpc_resolver* resolver,
-                      grpc_channel_args** result, grpc_closure* on_complete);
+  void (*destroy)(grpc_resolver* resolver);
+  void (*shutdown_locked)(grpc_resolver* resolver);
+  void (*channel_saw_error_locked)(grpc_resolver* resolver);
+  void (*next_locked)(grpc_resolver* resolver, grpc_channel_args** result,
+                      grpc_closure* on_complete);
 };
 
 #ifndef NDEBUG
 #define GRPC_RESOLVER_REF(p, r) grpc_resolver_ref((p), __FILE__, __LINE__, (r))
-#define GRPC_RESOLVER_UNREF(e, p, r) \
-  grpc_resolver_unref((e), (p), __FILE__, __LINE__, (r))
+#define GRPC_RESOLVER_UNREF(p, r) \
+  grpc_resolver_unref((p), __FILE__, __LINE__, (r))
 void grpc_resolver_ref(grpc_resolver* policy, const char* file, int line,
                        const char* reason);
-void grpc_resolver_unref(grpc_exec_ctx* exec_ctx, grpc_resolver* policy,
-                         const char* file, int line, const char* reason);
+void grpc_resolver_unref(grpc_resolver* policy, const char* file, int line,
+                         const char* reason);
 #else
 #define GRPC_RESOLVER_REF(p, r) grpc_resolver_ref((p))
-#define GRPC_RESOLVER_UNREF(e, p, r) grpc_resolver_unref((e), (p))
+#define GRPC_RESOLVER_UNREF(p, r) grpc_resolver_unref((p))
 void grpc_resolver_ref(grpc_resolver* policy);
-void grpc_resolver_unref(grpc_exec_ctx* exec_ctx, grpc_resolver* policy);
+void grpc_resolver_unref(grpc_resolver* policy);
 #endif
 
 void grpc_resolver_init(grpc_resolver* resolver,
                         const grpc_resolver_vtable* vtable,
                         grpc_combiner* combiner);
 
-void grpc_resolver_shutdown_locked(grpc_exec_ctx* exec_ctx,
-                                   grpc_resolver* resolver);
+void grpc_resolver_shutdown_locked(grpc_resolver* resolver);
 
 /** Notification that the channel has seen an error on some address.
     Can be used as a hint that re-resolution is desirable soon.
 
     Must be called from the combiner passed as a resolver_arg at construction
     time.*/
-void grpc_resolver_channel_saw_error_locked(grpc_exec_ctx* exec_ctx,
-                                            grpc_resolver* resolver);
+void grpc_resolver_channel_saw_error_locked(grpc_resolver* resolver);
 
 /** Get the next result from the resolver.  Expected to set \a *result with
     new channel args and then schedule \a on_complete for execution.
@@ -85,12 +78,8 @@ void grpc_resolver_channel_saw_error_locked(grpc_exec_ctx* exec_ctx,
 
     Must be called from the combiner passed as a resolver_arg at construction
     time.*/
-void grpc_resolver_next_locked(grpc_exec_ctx* exec_ctx, grpc_resolver* resolver,
+void grpc_resolver_next_locked(grpc_resolver* resolver,
                                grpc_channel_args** result,
                                grpc_closure* on_complete);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_H */

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/dns_resolver_ares.cc

@@ -34,16 +34,16 @@
 #include "src/core/ext/filters/client_channel/resolver_registry.h"
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gpr++/manual_constructor.h"
+#include "src/core/lib/gpr/env.h"
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/iomgr/gethostname.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/json/json.h"
-#include "src/core/lib/support/env.h"
-#include "src/core/lib/support/string.h"
 #include "src/core/lib/transport/service_config.h"
 
-#define GRPC_DNS_MIN_CONNECT_TIMEOUT_SECONDS 1
 #define GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS 1
 #define GRPC_DNS_RECONNECT_BACKOFF_MULTIPLIER 1.6
 #define GRPC_DNS_RECONNECT_MAX_BACKOFF_SECONDS 120
@@ -89,7 +89,7 @@ typedef struct {
   bool have_retry_timer;
   grpc_timer retry_timer;
   /** retry backoff state */
-  grpc_backoff backoff_state;
+  grpc_core::ManualConstructor<grpc_core::BackOff> backoff;
 
   /** currently resolving addresses */
   grpc_lb_addresses* lb_addresses;
@@ -97,17 +97,14 @@ typedef struct {
   char* service_config_json;
 } ares_dns_resolver;
 
-static void dns_ares_destroy(grpc_exec_ctx* exec_ctx, grpc_resolver* r);
+static void dns_ares_destroy(grpc_resolver* r);
 
-static void dns_ares_start_resolving_locked(grpc_exec_ctx* exec_ctx,
-                                            ares_dns_resolver* r);
-static void dns_ares_maybe_finish_next_locked(grpc_exec_ctx* exec_ctx,
-                                              ares_dns_resolver* r);
+static void dns_ares_start_resolving_locked(ares_dns_resolver* r);
+static void dns_ares_maybe_finish_next_locked(ares_dns_resolver* r);
 
-static void dns_ares_shutdown_locked(grpc_exec_ctx* exec_ctx, grpc_resolver* r);
-static void dns_ares_channel_saw_error_locked(grpc_exec_ctx* exec_ctx,
-                                              grpc_resolver* r);
-static void dns_ares_next_locked(grpc_exec_ctx* exec_ctx, grpc_resolver* r,
+static void dns_ares_shutdown_locked(grpc_resolver* r);
+static void dns_ares_channel_saw_error_locked(grpc_resolver* r);
+static void dns_ares_next_locked(grpc_resolver* r,
                                  grpc_channel_args** target_result,
                                  grpc_closure* on_complete);
 
@@ -115,43 +112,39 @@ static const grpc_resolver_vtable dns_ares_resolver_vtable = {
     dns_ares_destroy, dns_ares_shutdown_locked,
     dns_ares_channel_saw_error_locked, dns_ares_next_locked};
 
-static void dns_ares_shutdown_locked(grpc_exec_ctx* exec_ctx,
-                                     grpc_resolver* resolver) {
+static void dns_ares_shutdown_locked(grpc_resolver* resolver) {
   ares_dns_resolver* r = (ares_dns_resolver*)resolver;
   if (r->have_retry_timer) {
-    grpc_timer_cancel(exec_ctx, &r->retry_timer);
+    grpc_timer_cancel(&r->retry_timer);
   }
   if (r->pending_request != nullptr) {
-    grpc_cancel_ares_request(exec_ctx, r->pending_request);
+    grpc_cancel_ares_request(r->pending_request);
   }
   if (r->next_completion != nullptr) {
     *r->target_result = nullptr;
-    GRPC_CLOSURE_SCHED(
-        exec_ctx, r->next_completion,
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Resolver Shutdown"));
+    GRPC_CLOSURE_SCHED(r->next_completion, GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                                               "Resolver Shutdown"));
     r->next_completion = nullptr;
   }
 }
 
-static void dns_ares_channel_saw_error_locked(grpc_exec_ctx* exec_ctx,
-                                              grpc_resolver* resolver) {
+static void dns_ares_channel_saw_error_locked(grpc_resolver* resolver) {
   ares_dns_resolver* r = (ares_dns_resolver*)resolver;
   if (!r->resolving) {
-    grpc_backoff_reset(&r->backoff_state);
-    dns_ares_start_resolving_locked(exec_ctx, r);
+    r->backoff->Reset();
+    dns_ares_start_resolving_locked(r);
   }
 }
 
-static void dns_ares_on_retry_timer_locked(grpc_exec_ctx* exec_ctx, void* arg,
-                                           grpc_error* error) {
+static void dns_ares_on_retry_timer_locked(void* arg, grpc_error* error) {
   ares_dns_resolver* r = (ares_dns_resolver*)arg;
   r->have_retry_timer = false;
   if (error == GRPC_ERROR_NONE) {
     if (!r->resolving) {
-      dns_ares_start_resolving_locked(exec_ctx, r);
+      dns_ares_start_resolving_locked(r);
     }
   }
-  GRPC_RESOLVER_UNREF(exec_ctx, &r->base, "retry-timer");
+  GRPC_RESOLVER_UNREF(&r->base, "retry-timer");
 }
 
 static bool value_in_json_array(grpc_json* array, const char* value) {
@@ -226,8 +219,7 @@ static char* choose_service_config(char* service_config_choice_json) {
   return service_config;
 }
 
-static void dns_ares_on_resolved_locked(grpc_exec_ctx* exec_ctx, void* arg,
-                                        grpc_error* error) {
+static void dns_ares_on_resolved_locked(void* arg, grpc_error* error) {
   ares_dns_resolver* r = (ares_dns_resolver*)arg;
   grpc_channel_args* result = nullptr;
   GPR_ASSERT(r->resolving);
@@ -268,13 +260,12 @@ static void dns_ares_on_resolved_locked(grpc_exec_ctx* exec_ctx, void* arg,
         num_args_to_add);
     if (service_config != nullptr) grpc_service_config_destroy(service_config);
     gpr_free(service_config_string);
-    grpc_lb_addresses_destroy(exec_ctx, r->lb_addresses);
+    grpc_lb_addresses_destroy(r->lb_addresses);
   } else {
     const char* msg = grpc_error_string(error);
     gpr_log(GPR_DEBUG, "dns resolution failed: %s", msg);
-    grpc_millis next_try =
-        grpc_backoff_step(exec_ctx, &r->backoff_state).next_attempt_start_time;
-    grpc_millis timeout = next_try - grpc_exec_ctx_now(exec_ctx);
+    grpc_millis next_try = r->backoff->NextAttemptTime();
+    grpc_millis timeout = next_try - grpc_core::ExecCtx::Get()->Now();
     gpr_log(GPR_INFO, "dns resolution failed (will retry): %s",
             grpc_error_string(error));
     GPR_ASSERT(!r->have_retry_timer);
@@ -285,20 +276,19 @@ static void dns_ares_on_resolved_locked(grpc_exec_ctx* exec_ctx, void* arg,
     } else {
       gpr_log(GPR_DEBUG, "retrying immediately");
     }
-    grpc_timer_init(exec_ctx, &r->retry_timer, next_try,
+    grpc_timer_init(&r->retry_timer, next_try,
                     &r->dns_ares_on_retry_timer_locked);
   }
   if (r->resolved_result != nullptr) {
-    grpc_channel_args_destroy(exec_ctx, r->resolved_result);
+    grpc_channel_args_destroy(r->resolved_result);
   }
   r->resolved_result = result;
   r->resolved_version++;
-  dns_ares_maybe_finish_next_locked(exec_ctx, r);
-  GRPC_RESOLVER_UNREF(exec_ctx, &r->base, "dns-resolving");
+  dns_ares_maybe_finish_next_locked(r);
+  GRPC_RESOLVER_UNREF(&r->base, "dns-resolving");
 }
 
-static void dns_ares_next_locked(grpc_exec_ctx* exec_ctx,
-                                 grpc_resolver* resolver,
+static void dns_ares_next_locked(grpc_resolver* resolver,
                                  grpc_channel_args** target_result,
                                  grpc_closure* on_complete) {
   gpr_log(GPR_DEBUG, "dns_ares_next is called.");
@@ -307,57 +297,54 @@ static void dns_ares_next_locked(grpc_exec_ctx* exec_ctx,
   r->next_completion = on_complete;
   r->target_result = target_result;
   if (r->resolved_version == 0 && !r->resolving) {
-    grpc_backoff_reset(&r->backoff_state);
-    dns_ares_start_resolving_locked(exec_ctx, r);
+    r->backoff->Reset();
+    dns_ares_start_resolving_locked(r);
   } else {
-    dns_ares_maybe_finish_next_locked(exec_ctx, r);
+    dns_ares_maybe_finish_next_locked(r);
   }
 }
 
-static void dns_ares_start_resolving_locked(grpc_exec_ctx* exec_ctx,
-                                            ares_dns_resolver* r) {
+static void dns_ares_start_resolving_locked(ares_dns_resolver* r) {
   GRPC_RESOLVER_REF(&r->base, "dns-resolving");
   GPR_ASSERT(!r->resolving);
   r->resolving = true;
   r->lb_addresses = nullptr;
   r->service_config_json = nullptr;
   r->pending_request = grpc_dns_lookup_ares(
-      exec_ctx, r->dns_server, r->name_to_resolve, r->default_port,
-      r->interested_parties, &r->dns_ares_on_resolved_locked, &r->lb_addresses,
+      r->dns_server, r->name_to_resolve, r->default_port, r->interested_parties,
+      &r->dns_ares_on_resolved_locked, &r->lb_addresses,
       true /* check_grpclb */,
       r->request_service_config ? &r->service_config_json : nullptr);
 }
 
-static void dns_ares_maybe_finish_next_locked(grpc_exec_ctx* exec_ctx,
-                                              ares_dns_resolver* r) {
+static void dns_ares_maybe_finish_next_locked(ares_dns_resolver* r) {
   if (r->next_completion != nullptr &&
       r->resolved_version != r->published_version) {
     *r->target_result = r->resolved_result == nullptr
                             ? nullptr
                             : grpc_channel_args_copy(r->resolved_result);
     gpr_log(GPR_DEBUG, "dns_ares_maybe_finish_next_locked");
-    GRPC_CLOSURE_SCHED(exec_ctx, r->next_completion, GRPC_ERROR_NONE);
+    GRPC_CLOSURE_SCHED(r->next_completion, GRPC_ERROR_NONE);
     r->next_completion = nullptr;
     r->published_version = r->resolved_version;
   }
 }
 
-static void dns_ares_destroy(grpc_exec_ctx* exec_ctx, grpc_resolver* gr) {
+static void dns_ares_destroy(grpc_resolver* gr) {
   gpr_log(GPR_DEBUG, "dns_ares_destroy");
   ares_dns_resolver* r = (ares_dns_resolver*)gr;
   if (r->resolved_result != nullptr) {
-    grpc_channel_args_destroy(exec_ctx, r->resolved_result);
+    grpc_channel_args_destroy(r->resolved_result);
   }
-  grpc_pollset_set_destroy(exec_ctx, r->interested_parties);
+  grpc_pollset_set_destroy(r->interested_parties);
   gpr_free(r->dns_server);
   gpr_free(r->name_to_resolve);
   gpr_free(r->default_port);
-  grpc_channel_args_destroy(exec_ctx, r->channel_args);
+  grpc_channel_args_destroy(r->channel_args);
   gpr_free(r);
 }
 
-static grpc_resolver* dns_ares_create(grpc_exec_ctx* exec_ctx,
-                                      grpc_resolver_args* args,
+static grpc_resolver* dns_ares_create(grpc_resolver_args* args,
                                       const char* default_port) {
   /* Get name from args. */
   const char* path = args->uri->path;
@@ -378,14 +365,15 @@ static grpc_resolver* dns_ares_create(grpc_exec_ctx* exec_ctx,
       arg, (grpc_integer_options){false, false, true});
   r->interested_parties = grpc_pollset_set_create();
   if (args->pollset_set != nullptr) {
-    grpc_pollset_set_add_pollset_set(exec_ctx, r->interested_parties,
-                                     args->pollset_set);
+    grpc_pollset_set_add_pollset_set(r->interested_parties, args->pollset_set);
   }
-  grpc_backoff_init(
-      &r->backoff_state, GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS * 1000,
-      GRPC_DNS_RECONNECT_BACKOFF_MULTIPLIER, GRPC_DNS_RECONNECT_JITTER,
-      GRPC_DNS_MIN_CONNECT_TIMEOUT_SECONDS * 1000,
-      GRPC_DNS_RECONNECT_MAX_BACKOFF_SECONDS * 1000);
+  grpc_core::BackOff::Options backoff_options;
+  backoff_options
+      .set_initial_backoff(GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS * 1000)
+      .set_multiplier(GRPC_DNS_RECONNECT_BACKOFF_MULTIPLIER)
+      .set_jitter(GRPC_DNS_RECONNECT_JITTER)
+      .set_max_backoff(GRPC_DNS_RECONNECT_MAX_BACKOFF_SECONDS * 1000);
+  r->backoff.Init(grpc_core::BackOff(backoff_options));
   GRPC_CLOSURE_INIT(&r->dns_ares_on_retry_timer_locked,
                     dns_ares_on_retry_timer_locked, r,
                     grpc_combiner_scheduler(r->base.combiner));
@@ -404,9 +392,8 @@ static void dns_ares_factory_ref(grpc_resolver_factory* factory) {}
 static void dns_ares_factory_unref(grpc_resolver_factory* factory) {}
 
 static grpc_resolver* dns_factory_create_resolver(
-    grpc_exec_ctx* exec_ctx, grpc_resolver_factory* factory,
-    grpc_resolver_args* args) {
-  return dns_ares_create(exec_ctx, args, "https");
+    grpc_resolver_factory* factory, grpc_resolver_args* args) {
+  return dns_ares_create(args, "https");
 }
 
 static char* dns_ares_factory_get_default_host_name(
@@ -425,7 +412,7 @@ static grpc_resolver_factory* dns_ares_resolver_factory_create() {
   return &dns_resolver_factory;
 }
 
-extern "C" void grpc_resolver_dns_ares_init(void) {
+void grpc_resolver_dns_ares_init(void) {
   char* resolver = gpr_getenv("GRPC_DNS_RESOLVER");
   /* TODO(zyc): Turn on c-ares based resolver by default after the address
      sorter and the CNAME support are added. */
@@ -441,7 +428,7 @@ extern "C" void grpc_resolver_dns_ares_init(void) {
   gpr_free(resolver);
 }
 
-extern "C" void grpc_resolver_dns_ares_shutdown(void) {
+void grpc_resolver_dns_ares_shutdown(void) {
   char* resolver = gpr_getenv("GRPC_DNS_RESOLVER");
   if (resolver != nullptr && gpr_stricmp(resolver, "ares") == 0) {
     grpc_ares_cleanup();
@@ -451,8 +438,8 @@ extern "C" void grpc_resolver_dns_ares_shutdown(void) {
 
 #else /* GRPC_ARES == 1 && !defined(GRPC_UV) */
 
-extern "C" void grpc_resolver_dns_ares_init(void) {}
+void grpc_resolver_dns_ares_init(void) {}
 
-extern "C" void grpc_resolver_dns_ares_shutdown(void) {}
+void grpc_resolver_dns_ares_shutdown(void) {}
 
 #endif /* GRPC_ARES == 1 && !defined(GRPC_UV) */