grpc 1.34.0 → 1.35.0.pre1

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <ares.h>
+
 #include "src/core/ext/filters/client_channel/server_address.h"
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/polling_entity.h"
@@ -93,5 +95,8 @@ bool grpc_ares_query_ipv6();
 void grpc_cares_wrapper_address_sorting_sort(
     const grpc_ares_request* request, grpc_core::ServerAddressList* addresses);
 
+/* Exposed in this header for C-core tests only */
+extern void (*grpc_ares_test_only_inject_config)(ares_channel channel);
+
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_C_ARES_GRPC_ARES_WRAPPER_H \
         */

data/src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.cc

@@ -74,7 +74,7 @@ class NativeDnsResolver : public Resolver {
   void OnResolvedLocked(grpc_error* error);
 
   /// name to resolve
-  char* name_to_resolve_ = nullptr;
+  std::string name_to_resolve_;
   /// channel args
   grpc_channel_args* channel_args_ = nullptr;
   /// pollset_set to drive the name resolution process
@@ -107,9 +107,7 @@ NativeDnsResolver::NativeDnsResolver(ResolverArgs args)
               .set_multiplier(GRPC_DNS_RECONNECT_BACKOFF_MULTIPLIER)
               .set_jitter(GRPC_DNS_RECONNECT_JITTER)
               .set_max_backoff(GRPC_DNS_RECONNECT_MAX_BACKOFF_SECONDS * 1000)) {
-  char* path = args.uri->path;
-  if (path[0] == '/') ++path;
-  name_to_resolve_ = gpr_strdup(path);
+  name_to_resolve_ = std::string(absl::StripPrefix(args.uri.path(), "/"));
   channel_args_ = grpc_channel_args_copy(args.args);
   const grpc_arg* arg = grpc_channel_args_find(
       args.args, GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS);
@@ -124,7 +122,6 @@ NativeDnsResolver::NativeDnsResolver(ResolverArgs args)
 NativeDnsResolver::~NativeDnsResolver() {
   grpc_channel_args_destroy(channel_args_);
   grpc_pollset_set_destroy(interested_parties_);
-  gpr_free(name_to_resolve_);
 }
 
 void NativeDnsResolver::StartLocked() { MaybeStartResolvingLocked(); }
@@ -269,8 +266,8 @@ void NativeDnsResolver::StartResolvingLocked() {
   addresses_ = nullptr;
   GRPC_CLOSURE_INIT(&on_resolved_, NativeDnsResolver::OnResolved, this,
                     grpc_schedule_on_exec_ctx);
-  grpc_resolve_address(name_to_resolve_, kDefaultPort, interested_parties_,
-                       &on_resolved_, &addresses_);
+  grpc_resolve_address(name_to_resolve_.c_str(), kDefaultPort,
+                       interested_parties_, &on_resolved_, &addresses_);
   last_resolution_timestamp_ = grpc_core::ExecCtx::Get()->Now();
 }
 
@@ -280,8 +277,8 @@ void NativeDnsResolver::StartResolvingLocked() {
 
 class NativeDnsResolverFactory : public ResolverFactory {
  public:
-  bool IsValidUri(const grpc_uri* uri) const override {
-    if (GPR_UNLIKELY(0 != strcmp(uri->authority, ""))) {
+  bool IsValidUri(const URI& uri) const override {
+    if (GPR_UNLIKELY(!uri.authority().empty())) {
       gpr_log(GPR_ERROR, "authority based dns uri's not supported");
       return false;
     }

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

@@ -339,7 +339,7 @@ grpc_arg FakeResolverResponseGenerator::MakeChannelArg(
     FakeResolverResponseGenerator* generator) {
   grpc_arg arg;
   arg.type = GRPC_ARG_POINTER;
-  arg.key = (char*)GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR;
+  arg.key = const_cast<char*>(GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR);
   arg.value.pointer.p = generator;
   arg.value.pointer.vtable = &response_generator_arg_vtable;
   return arg;
@@ -362,7 +362,7 @@ namespace {
 
 class FakeResolverFactory : public ResolverFactory {
  public:
-  bool IsValidUri(const grpc_uri* /*uri*/) const override { return true; }
+  bool IsValidUri(const URI& /*uri*/) const override { return true; }
 
   OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
     return MakeOrphanable<FakeResolver>(std::move(args));

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

@@ -23,6 +23,8 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "absl/strings/str_split.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
@@ -78,30 +80,20 @@ void SockaddrResolver::StartLocked() {
 // Factory
 //
 
-void DoNothing(void* /*ignored*/) {}
-
-bool ParseUri(const grpc_uri* uri,
-              bool parse(const grpc_uri* uri, grpc_resolved_address* dst),
+bool ParseUri(const URI& uri,
+              bool parse(const URI& uri, grpc_resolved_address* dst),
               ServerAddressList* addresses) {
-  if (0 != strcmp(uri->authority, "")) {
+  if (!uri.authority().empty()) {
     gpr_log(GPR_ERROR, "authority-based URIs not supported by the %s scheme",
-            uri->scheme);
+            uri.scheme().c_str());
     return false;
   }
   // Construct addresses.
-  grpc_slice path_slice =
-      grpc_slice_new(uri->path, strlen(uri->path), DoNothing);
-  grpc_slice_buffer path_parts;
-  grpc_slice_buffer_init(&path_parts);
-  grpc_slice_split(path_slice, ",", &path_parts);
   bool errors_found = false;
-  for (size_t i = 0; i < path_parts.count; i++) {
-    grpc_uri ith_uri = *uri;
-    grpc_core::UniquePtr<char> part_str(
-        grpc_slice_to_c_string(path_parts.slices[i]));
-    ith_uri.path = part_str.get();
+  for (absl::string_view ith_path : absl::StrSplit(uri.path(), ',')) {
+    URI ith_uri(uri.scheme(), "", std::string(ith_path), {}, "");
     grpc_resolved_address addr;
-    if (!parse(&ith_uri, &addr)) {
+    if (!parse(ith_uri, &addr)) {
       errors_found = true;
       break;
     }
@@ -109,14 +101,11 @@ bool ParseUri(const grpc_uri* uri,
       addresses->emplace_back(addr, nullptr /* args */);
     }
   }
-  grpc_slice_buffer_destroy_internal(&path_parts);
-  grpc_slice_unref_internal(path_slice);
   return !errors_found;
 }
 
 OrphanablePtr<Resolver> CreateSockaddrResolver(
-    ResolverArgs args,
-    bool parse(const grpc_uri* uri, grpc_resolved_address* dst)) {
+    ResolverArgs args, bool parse(const URI& uri, grpc_resolved_address* dst)) {
   ServerAddressList addresses;
   if (!ParseUri(args.uri, parse, &addresses)) return nullptr;
   // Instantiate resolver.
@@ -126,7 +115,7 @@ OrphanablePtr<Resolver> CreateSockaddrResolver(
 
 class IPv4ResolverFactory : public ResolverFactory {
  public:
-  bool IsValidUri(const grpc_uri* uri) const override {
+  bool IsValidUri(const URI& uri) const override {
     return ParseUri(uri, grpc_parse_ipv4, nullptr);
   }
 
@@ -139,7 +128,7 @@ class IPv4ResolverFactory : public ResolverFactory {
 
 class IPv6ResolverFactory : public ResolverFactory {
  public:
-  bool IsValidUri(const grpc_uri* uri) const override {
+  bool IsValidUri(const URI& uri) const override {
     return ParseUri(uri, grpc_parse_ipv6, nullptr);
   }
 
@@ -153,7 +142,7 @@ class IPv6ResolverFactory : public ResolverFactory {
 #ifdef GRPC_HAVE_UNIX_SOCKET
 class UnixResolverFactory : public ResolverFactory {
  public:
-  bool IsValidUri(const grpc_uri* uri) const override {
+  bool IsValidUri(const URI& uri) const override {
     return ParseUri(uri, grpc_parse_unix, nullptr);
   }
 
@@ -161,9 +150,8 @@ class UnixResolverFactory : public ResolverFactory {
     return CreateSockaddrResolver(std::move(args), grpc_parse_unix);
   }
 
-  grpc_core::UniquePtr<char> GetDefaultAuthority(
-      grpc_uri* /*uri*/) const override {
-    return grpc_core::UniquePtr<char>(gpr_strdup("localhost"));
+  std::string GetDefaultAuthority(const URI& uri) const override {
+    return "localhost";
   }
 
   const char* scheme() const override { return "unix"; }
@@ -171,7 +159,7 @@ class UnixResolverFactory : public ResolverFactory {
 
 class UnixAbstractResolverFactory : public ResolverFactory {
  public:
-  bool IsValidUri(const grpc_uri* uri) const override {
+  bool IsValidUri(const URI& uri) const override {
     return ParseUri(uri, grpc_parse_unix_abstract, nullptr);
   }
 
@@ -179,9 +167,8 @@ class UnixAbstractResolverFactory : public ResolverFactory {
     return CreateSockaddrResolver(std::move(args), grpc_parse_unix_abstract);
   }
 
-  grpc_core::UniquePtr<char> GetDefaultAuthority(
-      grpc_uri* /*uri*/) const override {
-    return grpc_core::UniquePtr<char>(gpr_strdup("localhost"));
+  std::string GetDefaultAuthority(const URI& /*uri*/) const override {
+    return "localhost";
   }
 
   const char* scheme() const override { return "unix-abstract"; }

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

@@ -48,11 +48,9 @@ class XdsResolver : public Resolver {
   explicit XdsResolver(ResolverArgs args)
       : Resolver(std::move(args.work_serializer),
                  std::move(args.result_handler)),
+        server_name_(absl::StripPrefix(args.uri.path(), "/")),
         args_(grpc_channel_args_copy(args.args)),
         interested_parties_(args.pollset_set) {
-    char* path = args.uri->path;
-    if (path[0] == '/') ++path;
-    server_name_ = path;
     if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
       gpr_log(GPR_INFO, "[xds_resolver %p] created for server name %s", this,
               server_name_.c_str());
@@ -762,8 +760,8 @@ void XdsResolver::MaybeRemoveUnusedClusters() {
 
 class XdsResolverFactory : public ResolverFactory {
  public:
-  bool IsValidUri(const grpc_uri* uri) const override {
-    if (GPR_UNLIKELY(0 != strcmp(uri->authority, ""))) {
+  bool IsValidUri(const URI& uri) const override {
+    if (GPR_UNLIKELY(!uri.authority().empty())) {
       gpr_log(GPR_ERROR, "URI authority not supported");
       return false;
     }

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

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/strings/strip.h"
+
 #include <grpc/support/string_util.h>
 
 #include "src/core/ext/filters/client_channel/resolver.h"
@@ -33,7 +35,7 @@ namespace grpc_core {
 
 struct ResolverArgs {
   /// The parsed URI to resolve.
-  grpc_uri* uri = nullptr;
+  URI uri;
   /// Channel args to be included in resolver results.
   const grpc_channel_args* args = nullptr;
   /// Used to drive I/O in the name resolution process.
@@ -48,17 +50,15 @@ class ResolverFactory {
  public:
   /// Returns a bool indicating whether the input uri is valid to create a
   /// resolver.
-  virtual bool IsValidUri(const grpc_uri* uri) const = 0;
+  virtual bool IsValidUri(const URI& uri) const = 0;
 
   /// Returns a new resolver instance.
   virtual OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const = 0;
 
   /// Returns a string representing the default authority to use for this
   /// scheme.
-  virtual grpc_core::UniquePtr<char> GetDefaultAuthority(grpc_uri* uri) const {
-    const char* path = uri->path;
-    if (path[0] == '/') ++path;
-    return grpc_core::UniquePtr<char>(gpr_strdup(path));
+  virtual std::string GetDefaultAuthority(const URI& uri) const {
+    return std::string(absl::StripPrefix(uri.path(), "/"));
   }
 
   /// Returns the URI scheme that this factory implements.

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

@@ -24,6 +24,7 @@
 
 #include "absl/container/inlined_vector.h"
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -50,9 +51,9 @@ class RegistryState {
     factories_.push_back(std::move(factory));
   }
 
-  ResolverFactory* LookupResolverFactory(const char* scheme) const {
+  ResolverFactory* LookupResolverFactory(absl::string_view scheme) const {
     for (size_t i = 0; i < factories_.size(); ++i) {
-      if (strcmp(scheme, factories_[i]->scheme()) == 0) {
+      if (scheme == factories_[i]->scheme()) {
         return factories_[i].get();
       }
     }
@@ -65,26 +66,35 @@ class RegistryState {
   // point to the parsed URI.
   // If \a default_prefix_ needs to be prepended, sets \a canonical_target
   // to the canonical target string.
-  ResolverFactory* FindResolverFactory(const char* target, grpc_uri** uri,
+  ResolverFactory* FindResolverFactory(absl::string_view target, URI* uri,
                                        std::string* canonical_target) const {
     GPR_ASSERT(uri != nullptr);
-    *uri = grpc_uri_parse(target, true);
+    absl::StatusOr<URI> tmp_uri = URI::Parse(target);
     ResolverFactory* factory =
-        *uri == nullptr ? nullptr : LookupResolverFactory((*uri)->scheme);
-    if (factory == nullptr) {
-      grpc_uri_destroy(*uri);
-      *canonical_target = absl::StrCat(default_prefix_.get(), target);
-      *uri = grpc_uri_parse(canonical_target->c_str(), true);
-      factory =
-          *uri == nullptr ? nullptr : LookupResolverFactory((*uri)->scheme);
-      if (factory == nullptr) {
-        grpc_uri_destroy(grpc_uri_parse(target, false));
-        grpc_uri_destroy(grpc_uri_parse(canonical_target->c_str(), false));
-        gpr_log(GPR_ERROR, "don't know how to resolve '%s' or '%s'", target,
-                canonical_target->c_str());
-      }
+        tmp_uri.ok() ? LookupResolverFactory(tmp_uri->scheme()) : nullptr;
+    if (factory != nullptr) {
+      *uri = *tmp_uri;
+      return factory;
+    }
+    *canonical_target = absl::StrCat(default_prefix_.get(), target);
+    absl::StatusOr<URI> tmp_uri2 = URI::Parse(*canonical_target);
+    factory =
+        tmp_uri2.ok() ? LookupResolverFactory(tmp_uri2->scheme()) : nullptr;
+    if (factory != nullptr) {
+      *uri = *tmp_uri2;
+      return factory;
     }
-    return factory;
+    if (!tmp_uri.ok() || !tmp_uri2.ok()) {
+      gpr_log(GPR_ERROR, "%s",
+              absl::StrFormat("Error parsing URI(s). '%s':%s; '%s':%s", target,
+                              tmp_uri.status().ToString(), *canonical_target,
+                              tmp_uri2.status().ToString())
+                  .c_str());
+      return nullptr;
+    }
+    gpr_log(GPR_ERROR, "Don't know how to resolve '%s' or '%s'.",
+            std::string(target).c_str(), canonical_target->c_str());
+    return nullptr;
   }
 
  private:
@@ -114,10 +124,9 @@ void ResolverRegistry::Builder::ShutdownRegistry() {
   g_state = nullptr;
 }
 
-void ResolverRegistry::Builder::SetDefaultPrefix(
-    const char* default_resolver_prefix) {
+void ResolverRegistry::Builder::SetDefaultPrefix(const char* default_prefix) {
   InitRegistry();
-  g_state->SetDefaultPrefix(default_resolver_prefix);
+  g_state->SetDefaultPrefix(default_prefix);
 }
 
 void ResolverRegistry::Builder::RegisterResolverFactory(
@@ -135,14 +144,12 @@ ResolverFactory* ResolverRegistry::LookupResolverFactory(const char* scheme) {
   return g_state->LookupResolverFactory(scheme);
 }
 
-bool ResolverRegistry::IsValidTarget(const char* target) {
-  grpc_uri* uri = nullptr;
+bool ResolverRegistry::IsValidTarget(absl::string_view target) {
+  URI uri;
   std::string canonical_target;
   ResolverFactory* factory =
       g_state->FindResolverFactory(target, &uri, &canonical_target);
-  bool result = factory == nullptr ? false : factory->IsValidUri(uri);
-  grpc_uri_destroy(uri);
-  return result;
+  return factory == nullptr ? false : factory->IsValidUri(uri);
 }
 
 OrphanablePtr<Resolver> ResolverRegistry::CreateResolver(
@@ -151,12 +158,10 @@ OrphanablePtr<Resolver> ResolverRegistry::CreateResolver(
     std::shared_ptr<WorkSerializer> work_serializer,
     std::unique_ptr<Resolver::ResultHandler> result_handler) {
   GPR_ASSERT(g_state != nullptr);
-  grpc_uri* uri = nullptr;
   std::string canonical_target;
-  ResolverFactory* factory =
-      g_state->FindResolverFactory(target, &uri, &canonical_target);
   ResolverArgs resolver_args;
-  resolver_args.uri = uri;
+  ResolverFactory* factory = g_state->FindResolverFactory(
+      target, &resolver_args.uri, &canonical_target);
   resolver_args.args = args;
   resolver_args.pollset_set = pollset_set;
   resolver_args.work_serializer = std::move(work_serializer);
@@ -164,30 +169,26 @@ OrphanablePtr<Resolver> ResolverRegistry::CreateResolver(
   OrphanablePtr<Resolver> resolver =
       factory == nullptr ? nullptr
                          : factory->CreateResolver(std::move(resolver_args));
-  grpc_uri_destroy(uri);
   return resolver;
 }
 
-grpc_core::UniquePtr<char> ResolverRegistry::GetDefaultAuthority(
-    const char* target) {
+std::string ResolverRegistry::GetDefaultAuthority(absl::string_view target) {
   GPR_ASSERT(g_state != nullptr);
-  grpc_uri* uri = nullptr;
+  URI uri;
   std::string canonical_target;
   ResolverFactory* factory =
       g_state->FindResolverFactory(target, &uri, &canonical_target);
-  grpc_core::UniquePtr<char> authority =
-      factory == nullptr ? nullptr : factory->GetDefaultAuthority(uri);
-  grpc_uri_destroy(uri);
+  std::string authority =
+      factory == nullptr ? "" : factory->GetDefaultAuthority(uri);
   return authority;
 }
 
 grpc_core::UniquePtr<char> ResolverRegistry::AddDefaultPrefixIfNeeded(
     const char* target) {
   GPR_ASSERT(g_state != nullptr);
-  grpc_uri* uri = nullptr;
+  URI uri;
   std::string canonical_target;
   g_state->FindResolverFactory(target, &uri, &canonical_target);
-  grpc_uri_destroy(uri);
   return grpc_core::UniquePtr<char>(canonical_target.empty()
                                         ? gpr_strdup(target)
                                         : gpr_strdup(canonical_target.c_str()));

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

@@ -51,7 +51,7 @@ class ResolverRegistry {
   };
 
   /// Checks whether the user input \a target is valid to create a resolver.
-  static bool IsValidTarget(const char* target);
+  static bool IsValidTarget(absl::string_view target);
 
   /// Creates a resolver given \a target.
   /// First tries to parse \a target as a URI. If this succeeds, tries
@@ -73,7 +73,7 @@ class ResolverRegistry {
       std::unique_ptr<Resolver::ResultHandler> result_handler);
 
   /// Returns the default authority to pass from a client for \a target.
-  static grpc_core::UniquePtr<char> GetDefaultAuthority(const char* target);
+  static std::string GetDefaultAuthority(absl::string_view target);
 
   /// Returns \a target with the default prefix prepended, if needed.
   static grpc_core::UniquePtr<char> AddDefaultPrefixIfNeeded(

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

@@ -248,27 +248,25 @@ grpc_error* ParseRetryThrottling(
   return GRPC_ERROR_CREATE_FROM_VECTOR("retryPolicy", &error_list);
 }
 
-const char* ParseHealthCheckConfig(const Json& field, grpc_error** error) {
+absl::optional<std::string> ParseHealthCheckConfig(const Json& field,
+                                                   grpc_error** error) {
   GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
-  const char* service_name = nullptr;
   if (field.type() != Json::Type::OBJECT) {
     *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "field:healthCheckConfig error:should be of type object");
-    return nullptr;
+    return absl::nullopt;
   }
   std::vector<grpc_error*> error_list;
+  absl::optional<std::string> service_name;
   auto it = field.object_value().find("serviceName");
   if (it != field.object_value().end()) {
     if (it->second.type() != Json::Type::STRING) {
       error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "field:serviceName error:should be of type string"));
     } else {
-      service_name = it->second.string_value().c_str();
+      service_name = it->second.string_value();
     }
   }
-  if (!error_list.empty()) {
-    return nullptr;
-  }
   *error =
       GRPC_ERROR_CREATE_FROM_VECTOR("field:healthCheckConfig", &error_list);
   return service_name;
@@ -281,12 +279,8 @@ ClientChannelServiceConfigParser::ParseGlobalParams(
     const grpc_channel_args* /*args*/, const Json& json, grpc_error** error) {
   GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
   std::vector<grpc_error*> error_list;
-  RefCountedPtr<LoadBalancingPolicy::Config> parsed_lb_config;
-  std::string lb_policy_name;
-  absl::optional<ClientChannelGlobalParsedConfig::RetryThrottling>
-      retry_throttling;
-  const char* health_check_service_name = nullptr;
   // Parse LB config.
+  RefCountedPtr<LoadBalancingPolicy::Config> parsed_lb_config;
   auto it = json.object_value().find("loadBalancingConfig");
   if (it != json.object_value().end()) {
     grpc_error* parse_error = GRPC_ERROR_NONE;
@@ -300,6 +294,7 @@ ClientChannelServiceConfigParser::ParseGlobalParams(
     }
   }
   // Parse deprecated LB policy.
+  std::string lb_policy_name;
   it = json.object_value().find("loadBalancingPolicy");
   if (it != json.object_value().end()) {
     if (it->second.type() != Json::Type::STRING) {
@@ -325,6 +320,8 @@ ClientChannelServiceConfigParser::ParseGlobalParams(
     }
   }
   // Parse retry throttling.
+  absl::optional<ClientChannelGlobalParsedConfig::RetryThrottling>
+      retry_throttling;
   it = json.object_value().find("retryThrottling");
   if (it != json.object_value().end()) {
     ClientChannelGlobalParsedConfig::RetryThrottling data;
@@ -336,6 +333,7 @@ ClientChannelServiceConfigParser::ParseGlobalParams(
     }
   }
   // Parse health check config.
+  absl::optional<std::string> health_check_service_name;
   it = json.object_value().find("healthCheckConfig");
   if (it != json.object_value().end()) {
     grpc_error* parsing_error = GRPC_ERROR_NONE;
@@ -350,7 +348,7 @@ ClientChannelServiceConfigParser::ParseGlobalParams(
   if (*error == GRPC_ERROR_NONE) {
     return absl::make_unique<ClientChannelGlobalParsedConfig>(
         std::move(parsed_lb_config), std::move(lb_policy_name),
-        retry_throttling, health_check_service_name);
+        retry_throttling, std::move(health_check_service_name));
   }
   return nullptr;
 }