grpc 1.48.0-x86_64-linux → 1.49.1-x86_64-linux

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

@@ -40,11 +40,11 @@
 #include "src/core/ext/filters/client_channel/client_channel_factory.h"
 #include "src/core/ext/filters/client_channel/config_selector.h"
 #include "src/core/ext/filters/client_channel/dynamic_filters.h"
-#include "src/core/ext/filters/client_channel/lb_policy.h"
 #include "src/core/ext/filters/client_channel/lb_policy/backend_metric_data.h"
 #include "src/core/ext/filters/client_channel/subchannel.h"
 #include "src/core/ext/filters/client_channel/subchannel_pool_interface.h"
 #include "src/core/lib/channel/call_tracer.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channelz.h"
@@ -56,12 +56,13 @@
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/gprpp/unique_type_name.h"
+#include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/polling_entity.h"
-#include "src/core/lib/iomgr/work_serializer.h"
+#include "src/core/lib/load_balancing/lb_policy.h"
 #include "src/core/lib/resolver/resolver.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/service_config/service_config.h"
@@ -91,9 +92,6 @@
 // Channel arg containing a pointer to the ClientChannel object.
 #define GRPC_ARG_CLIENT_CHANNEL "grpc.internal.client_channel"
 
-// Channel arg containing a pointer to the ServiceConfig object.
-#define GRPC_ARG_SERVICE_CONFIG_OBJ "grpc.internal.service_config_obj"
-
 // Max number of batches that can be pending on a call at any given
 // time.  This includes one batch for each of the following ops:
 //   recv_initial_metadata
@@ -112,6 +110,10 @@ class ClientChannel {
 
   class LoadBalancedCall;
 
+  // Flag that this object gets stored in channel args as a raw pointer.
+  struct RawPointerChannelArgTag {};
+  static absl::string_view ChannelArgName() { return GRPC_ARG_CLIENT_CHANNEL; }
+
   // Returns the ClientChannel object from channel, or null if channel
   // is not a client channel.
   static ClientChannel* GetFromChannel(Channel* channel);
@@ -166,6 +168,12 @@ class ClientChannel {
       ConfigSelector::CallDispatchController* call_dispatch_controller,
       bool is_transparent_retry);
 
+  // Exposed for testing only.
+  static ChannelArgs MakeSubchannelArgs(
+      const ChannelArgs& channel_args, const ChannelArgs& address_args,
+      const RefCountedPtr<SubchannelPoolInterface>& subchannel_pool,
+      const std::string& channel_default_authority);
+
  private:
   class CallData;
   class ResolverResultHandler;
@@ -247,8 +255,7 @@ class ClientChannel {
       const absl::optional<std::string>& health_check_service_name,
       Resolver::Result result) ABSL_EXCLUSIVE_LOCKS_REQUIRED(*work_serializer_);
   OrphanablePtr<LoadBalancingPolicy> CreateLbPolicyLocked(
-      const grpc_channel_args& args)
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(*work_serializer_);
+      const ChannelArgs& args) ABSL_EXCLUSIVE_LOCKS_REQUIRED(*work_serializer_);
 
   void UpdateStateAndPickerLocked(
       grpc_connectivity_state state, const absl::Status& status,
@@ -293,10 +300,10 @@ class ClientChannel {
   //
   // Fields set at construction and never modified.
   //
+  ChannelArgs channel_args_;
   const bool deadline_checking_enabled_;
   grpc_channel_stack* owning_stack_;
   ClientChannelFactory* client_channel_factory_;
-  const grpc_channel_args* channel_args_;
   RefCountedPtr<ServiceConfig> default_service_config_;
   std::string uri_to_resolve_;
   std::string default_authority_;

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

@@ -20,42 +20,13 @@
 
 #include "src/core/ext/filters/client_channel/client_channel_factory.h"
 
-#include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/useful.h"
-
 // Channel arg key for client channel factory.
 #define GRPC_ARG_CLIENT_CHANNEL_FACTORY "grpc.client_channel_factory"
 
 namespace grpc_core {
 
-namespace {
-
-void* factory_arg_copy(void* f) { return f; }
-void factory_arg_destroy(void* /*f*/) {}
-int factory_arg_cmp(void* factory1, void* factory2) {
-  return QsortCompare(factory1, factory2);
-}
-const grpc_arg_pointer_vtable factory_arg_vtable = {
-    factory_arg_copy, factory_arg_destroy, factory_arg_cmp};
-
-}  // namespace
-
 absl::string_view ClientChannelFactory::ChannelArgName() {
   return GRPC_ARG_CLIENT_CHANNEL_FACTORY;
 }
 
-grpc_arg ClientChannelFactory::CreateChannelArg(ClientChannelFactory* factory) {
-  return grpc_channel_arg_pointer_create(
-      const_cast<char*>(GRPC_ARG_CLIENT_CHANNEL_FACTORY), factory,
-      &factory_arg_vtable);
-}
-
-ClientChannelFactory* ClientChannelFactory::GetFromChannelArgs(
-    const grpc_channel_args* args) {
-  const grpc_arg* arg =
-      grpc_channel_args_find(args, GRPC_ARG_CLIENT_CHANNEL_FACTORY);
-  if (arg == nullptr || arg->type != GRPC_ARG_POINTER) return nullptr;
-  return static_cast<ClientChannelFactory*>(arg->value.pointer.p);
-}
-
 }  // namespace grpc_core

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

@@ -21,9 +21,8 @@
 
 #include "absl/strings/string_view.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
-
 #include "src/core/ext/filters/client_channel/subchannel.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 
@@ -37,16 +36,9 @@ class ClientChannelFactory {
 
   // Creates a subchannel with the specified args.
   virtual RefCountedPtr<Subchannel> CreateSubchannel(
-      const grpc_resolved_address& address, const grpc_channel_args* args) = 0;
+      const grpc_resolved_address& address, const ChannelArgs& args) = 0;
 
   static absl::string_view ChannelArgName();
-
-  // Returns a channel arg containing the specified factory.
-  static grpc_arg CreateChannelArg(ClientChannelFactory* factory);
-
-  // Returns the factory from args, or null if not found.
-  static ClientChannelFactory* GetFromChannelArgs(
-      const grpc_channel_args* args);
 };
 
 }  // namespace grpc_core

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

@@ -21,12 +21,12 @@
 #include "src/core/ext/filters/client_channel/backup_poller.h"
 #include "src/core/ext/filters/client_channel/client_channel.h"
 #include "src/core/ext/filters/client_channel/http_proxy.h"
-#include "src/core/ext/filters/client_channel/lb_policy_registry.h"
 #include "src/core/ext/filters/client_channel/proxy_mapper_registry.h"
 #include "src/core/ext/filters/client_channel/resolver_result_parsing.h"
 #include "src/core/ext/filters/client_channel/retry_service_config.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/load_balancing/lb_policy_registry.h"
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 

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

@@ -24,14 +24,18 @@
 #include <utility>
 #include <vector>
 
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/slice.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/service_config/service_config.h"
 #include "src/core/lib/service_config/service_config_call_data.h"
@@ -69,7 +73,7 @@ class ConfigSelector : public RefCounted<ConfigSelector> {
 
   struct CallConfig {
     // Can be set to indicate the call should be failed.
-    grpc_error_handle error = GRPC_ERROR_NONE;
+    absl::Status status;
     // The per-method parsed configs that will be passed to
     // ServiceConfigCallData.
     const ServiceConfigParser::ParsedConfigVector* method_configs = nullptr;
@@ -101,8 +105,7 @@ class ConfigSelector : public RefCounted<ConfigSelector> {
   // to determine what set of dynamic filters will be configured.
   virtual std::vector<const grpc_channel_filter*> GetFilters() { return {}; }
   // Modifies channel args to be passed to the dynamic filter stack.
-  // Takes ownership of argument.  Caller takes ownership of result.
-  virtual grpc_channel_args* ModifyChannelArgs(grpc_channel_args* args) {
+  virtual ChannelArgs ModifyChannelArgs(const ChannelArgs& args) {
     return args;
   }
 
@@ -111,6 +114,11 @@ class ConfigSelector : public RefCounted<ConfigSelector> {
   grpc_arg MakeChannelArg() const;
   static RefCountedPtr<ConfigSelector> GetFromChannelArgs(
       const grpc_channel_args& args);
+  static absl::string_view ChannelArgName() { return GRPC_ARG_CONFIG_SELECTOR; }
+  static int ChannelArgsCompare(const ConfigSelector* a,
+                                const ConfigSelector* b) {
+    return QsortCompare(a, b);
+  }
 };
 
 // Default ConfigSelector that gets the MethodConfig from the service config.

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

@@ -19,8 +19,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/impl/codegen/grpc_types.h>
-
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -46,20 +45,20 @@ class SubchannelConnector : public InternallyRefCounted<SubchannelConnector> {
     // Deadline for connection.
     Timestamp deadline;
     // Channel args to be passed to handshakers and transport.
-    const grpc_channel_args* channel_args;
+    ChannelArgs channel_args;
   };
 
   struct Result {
     // The connected transport.
     grpc_transport* transport = nullptr;
     // Channel args to be passed to filters.
-    const grpc_channel_args* channel_args = nullptr;
+    ChannelArgs channel_args;
     // Channelz socket node of the connected transport, if any.
     RefCountedPtr<channelz::SocketNode> socket_node;
 
     void Reset() {
       transport = nullptr;
-      channel_args = nullptr;
+      channel_args = ChannelArgs();
       socket_node.reset();
     }
   };

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

@@ -26,7 +26,6 @@
 #include <string>
 #include <vector>
 
-#include "absl/container/inlined_vector.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/match.h"
@@ -34,10 +33,11 @@
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
+#include "absl/types/optional.h"
 
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 
 #include "src/core/ext/filters/client_channel/proxy_mapper_registry.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -55,17 +55,14 @@ namespace {
 
 /**
  * Parses the 'https_proxy' env var (fallback on 'http_proxy') and returns the
- * proxy hostname to resolve or nullptr on error. Also sets 'user_cred' to user
+ * proxy hostname to resolve or nullopt on error. Also sets 'user_cred' to user
  * credentials if present in the 'http_proxy' env var, otherwise leaves it
- * unchanged. It is caller's responsibility to gpr_free user_cred.
+ * unchanged.
  */
-// TODO(hork): change this to return std::string
-char* GetHttpProxyServer(const grpc_channel_args* args, char** user_cred) {
+absl::optional<std::string> GetHttpProxyServer(
+    const ChannelArgs& args, absl::optional<std::string>* user_cred) {
   GPR_ASSERT(user_cred != nullptr);
   absl::StatusOr<URI> uri;
-  char* proxy_name = nullptr;
-  char** authority_strs = nullptr;
-  size_t authority_nstrs;
   /* We check the following places to determine the HTTP proxy to use, stopping
    * at the first one that is set:
    * 1. GRPC_ARG_HTTP_PROXY channel arg
@@ -74,29 +71,39 @@ char* GetHttpProxyServer(const grpc_channel_args* args, char** user_cred) {
    * 4. http_proxy environment variable
    * If none of the above are set, then no HTTP proxy will be used.
    */
-  auto uri_str = UniquePtr<char>(
-      gpr_strdup(grpc_channel_args_find_string(args, GRPC_ARG_HTTP_PROXY)));
-  if (uri_str == nullptr) uri_str = UniquePtr<char>(gpr_getenv("grpc_proxy"));
-  if (uri_str == nullptr) uri_str = UniquePtr<char>(gpr_getenv("https_proxy"));
-  if (uri_str == nullptr) uri_str = UniquePtr<char>(gpr_getenv("http_proxy"));
-  if (uri_str == nullptr) return nullptr;
+  absl::optional<std::string> uri_str =
+      args.GetOwnedString(GRPC_ARG_HTTP_PROXY);
+  auto get_env = [](const char* name) -> absl::optional<std::string> {
+    char* v = gpr_getenv(name);
+    if (v == nullptr) return absl::nullopt;
+    std::string s(v);
+    gpr_free(v);
+    return s;
+  };
+  if (!uri_str.has_value()) uri_str = get_env("grpc_proxy");
+  if (!uri_str.has_value()) uri_str = get_env("https_proxy");
+  if (!uri_str.has_value()) uri_str = get_env("http_proxy");
+  if (!uri_str.has_value()) return absl::nullopt;
   // an emtpy value means "don't use proxy"
-  if (uri_str.get()[0] == '\0') return nullptr;
-  uri = URI::Parse(uri_str.get());
+  if (uri_str->empty()) return absl::nullopt;
+  uri = URI::Parse(*uri_str);
   if (!uri.ok() || uri->authority().empty()) {
     gpr_log(GPR_ERROR, "cannot parse value of 'http_proxy' env var. Error: %s",
             uri.status().ToString().c_str());
-    return nullptr;
+    return absl::nullopt;
   }
   if (uri->scheme() != "http") {
     gpr_log(GPR_ERROR, "'%s' scheme not supported in proxy URI",
             uri->scheme().c_str());
-    return nullptr;
+    return absl::nullopt;
   }
   /* Split on '@' to separate user credentials from host */
+  char** authority_strs = nullptr;
+  size_t authority_nstrs;
   gpr_string_split(uri->authority().c_str(), "@", &authority_strs,
                    &authority_nstrs);
   GPR_ASSERT(authority_nstrs != 0); /* should have at least 1 string */
+  absl::optional<std::string> proxy_name;
   if (authority_nstrs == 1) {
     /* User cred not present in authority */
     proxy_name = authority_strs[0];
@@ -107,10 +114,10 @@ char* GetHttpProxyServer(const grpc_channel_args* args, char** user_cred) {
     gpr_log(GPR_DEBUG, "userinfo found in proxy URI");
   } else {
     /* Bad authority */
-    for (size_t i = 0; i < authority_nstrs; i++) {
-      gpr_free(authority_strs[i]);
-    }
-    proxy_name = nullptr;
+    proxy_name = absl::nullopt;
+  }
+  for (size_t i = 0; i < authority_nstrs; i++) {
+    gpr_free(authority_strs[i]);
   }
   gpr_free(authority_strs);
   return proxy_name;
@@ -129,35 +136,26 @@ std::string MaybeAddDefaultPort(absl::string_view target) {
 
 }  // namespace
 
-bool HttpProxyMapper::MapName(const char* server_uri,
-                              const grpc_channel_args* args,
-                              char** name_to_resolve,
-                              grpc_channel_args** new_args) {
-  if (!grpc_channel_args_find_bool(args, GRPC_ARG_ENABLE_HTTP_PROXY, true)) {
-    return false;
+absl::optional<std::string> HttpProxyMapper::MapName(
+    absl::string_view server_uri, ChannelArgs* args) {
+  if (!args->GetBool(GRPC_ARG_ENABLE_HTTP_PROXY).value_or(true)) {
+    return absl::nullopt;
   }
-  char* user_cred = nullptr;
-  *name_to_resolve = GetHttpProxyServer(args, &user_cred);
-  if (*name_to_resolve == nullptr) return false;
-  std::string server_target;
+  absl::optional<std::string> user_cred;
+  auto name_to_resolve = GetHttpProxyServer(*args, &user_cred);
+  if (!name_to_resolve.has_value()) return name_to_resolve;
   absl::StatusOr<URI> uri = URI::Parse(server_uri);
-  auto no_use_proxy = [&]() {
-    gpr_free(*name_to_resolve);
-    *name_to_resolve = nullptr;
-    gpr_free(user_cred);
-    return false;
-  };
   if (!uri.ok() || uri->path().empty()) {
     gpr_log(GPR_ERROR,
             "'http_proxy' environment variable set, but cannot "
             "parse server URI '%s' -- not using proxy. Error: %s",
-            server_uri, uri.status().ToString().c_str());
-    return no_use_proxy();
+            std::string(server_uri).c_str(), uri.status().ToString().c_str());
+    return absl::nullopt;
   }
   if (uri->scheme() == "unix") {
     gpr_log(GPR_INFO, "not using proxy for Unix domain socket '%s'",
-            server_uri);
-    return no_use_proxy();
+            std::string(server_uri).c_str());
+    return absl::nullopt;
   }
   /* Prefer using 'no_grpc_proxy'. Fallback on 'no_proxy' if it is not set. */
   auto no_proxy_str = UniquePtr<char>(gpr_getenv("no_grpc_proxy"));
@@ -173,42 +171,32 @@ bool HttpProxyMapper::MapName(const char* server_uri,
       gpr_log(GPR_INFO,
               "unable to split host and port, not checking no_proxy list for "
               "host '%s'",
-              server_uri);
+              std::string(server_uri).c_str());
     } else {
       std::vector<absl::string_view> no_proxy_hosts =
           absl::StrSplit(no_proxy_str.get(), ',', absl::SkipEmpty());
       for (const auto& no_proxy_entry : no_proxy_hosts) {
         if (absl::EndsWithIgnoreCase(server_host, no_proxy_entry)) {
           gpr_log(GPR_INFO, "not using proxy for host in no_proxy list '%s'",
-                  server_uri);
+                  std::string(server_uri).c_str());
           use_proxy = false;
           break;
         }
       }
-      if (!use_proxy) return no_use_proxy();
+      if (!use_proxy) return absl::nullopt;
     }
   }
-  server_target =
-      MaybeAddDefaultPort(absl::StripPrefix(uri->path(), "/")).c_str();
-  absl::InlinedVector<grpc_arg, 2> args_to_add;
-  args_to_add.push_back(grpc_channel_arg_string_create(
-      const_cast<char*>(GRPC_ARG_HTTP_CONNECT_SERVER),
-      const_cast<char*>(server_target.c_str())));
-  std::string header;
-  if (user_cred != nullptr) {
+  *args = args->Set(GRPC_ARG_HTTP_CONNECT_SERVER,
+                    MaybeAddDefaultPort(absl::StripPrefix(uri->path(), "/")));
+  if (user_cred.has_value()) {
     /* Use base64 encoding for user credentials as stated in RFC 7617 */
-    auto encoded_user_cred =
-        UniquePtr<char>(grpc_base64_encode(user_cred, strlen(user_cred), 0, 0));
-    header =
-        absl::StrCat("Proxy-Authorization:Basic ", encoded_user_cred.get());
-    args_to_add.push_back(grpc_channel_arg_string_create(
-        const_cast<char*>(GRPC_ARG_HTTP_CONNECT_HEADERS),
-        const_cast<char*>(header.c_str())));
+    auto encoded_user_cred = UniquePtr<char>(
+        grpc_base64_encode(user_cred->data(), user_cred->length(), 0, 0));
+    *args = args->Set(
+        GRPC_ARG_HTTP_CONNECT_HEADERS,
+        absl::StrCat("Proxy-Authorization:Basic ", encoded_user_cred.get()));
   }
-  *new_args = grpc_channel_args_copy_and_add(args, args_to_add.data(),
-                                             args_to_add.size());
-  gpr_free(user_cred);
-  return true;
+  return name_to_resolve;
 }
 
 void RegisterHttpProxyMapper() {

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

@@ -21,23 +21,26 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/impl/codegen/grpc_types.h>
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
 
 #include "src/core/ext/filters/client_channel/proxy_mapper.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 
 namespace grpc_core {
 
 class HttpProxyMapper : public ProxyMapperInterface {
  public:
-  bool MapName(const char* server_uri, const grpc_channel_args* args,
-               char** name_to_resolve, grpc_channel_args** new_args) override;
-
-  bool MapAddress(const grpc_resolved_address& /*address*/,
-                  const grpc_channel_args* /*args*/,
-                  grpc_resolved_address** /*new_address*/,
-                  grpc_channel_args** /*new_args*/) override {
-    return false;
+  absl::optional<std::string> MapName(absl::string_view server_uri,
+                                      ChannelArgs* args) override;
+
+  absl::optional<grpc_resolved_address> MapAddress(
+      const grpc_resolved_address& /*address*/,
+      ChannelArgs* /*args*/) override {
+    return absl::nullopt;
   }
 };
 

data/src/core/ext/filters/client_channel/lb_policy/child_policy_handler.cc

@@ -18,7 +18,6 @@
 
 #include "src/core/ext/filters/client_channel/lb_policy/child_policy_handler.h"
 
-#include <cstring>
 #include <memory>
 #include <string>
 
@@ -29,10 +28,11 @@
 #include <grpc/impl/codegen/connectivity_state.h>
 #include <grpc/support/log.h>
 
-#include "src/core/ext/filters/client_channel/lb_policy_registry.h"
-#include "src/core/ext/filters/client_channel/subchannel_interface.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/load_balancing/lb_policy_registry.h"
+#include "src/core/lib/load_balancing/subchannel_interface.h"
 #include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/transport/connectivity_state.h"
 
@@ -51,7 +51,7 @@ class ChildPolicyHandler::Helper
   ~Helper() override { parent_.reset(DEBUG_LOCATION, "Helper"); }
 
   RefCountedPtr<SubchannelInterface> CreateSubchannel(
-      ServerAddress address, const grpc_channel_args& args) override {
+      ServerAddress address, const ChannelArgs& args) override {
     if (parent_->shutting_down_) return nullptr;
     if (!CalledByCurrentChild() && !CalledByPendingChild()) return nullptr;
     return parent_->channel_control_helper()->CreateSubchannel(
@@ -229,11 +229,12 @@ void ChildPolicyHandler::UpdateLocked(UpdateArgs args) {
     if (GRPC_TRACE_FLAG_ENABLED(*tracer_)) {
       gpr_log(GPR_INFO,
               "[child_policy_handler %p] creating new %schild policy %s", this,
-              child_policy_ == nullptr ? "" : "pending ", args.config->name());
+              child_policy_ == nullptr ? "" : "pending ",
+              std::string(args.config->name()).c_str());
     }
     auto& lb_policy =
         child_policy_ == nullptr ? child_policy_ : pending_child_policy_;
-    lb_policy = CreateChildPolicy(args.config->name(), *args.args);
+    lb_policy = CreateChildPolicy(args.config->name(), args.args);
     policy_to_update = lb_policy.get();
   } else {
     // Cases 2a and 3a: update an existing policy.
@@ -273,24 +274,25 @@ void ChildPolicyHandler::ResetBackoffLocked() {
 }
 
 OrphanablePtr<LoadBalancingPolicy> ChildPolicyHandler::CreateChildPolicy(
-    const char* child_policy_name, const grpc_channel_args& args) {
+    absl::string_view child_policy_name, const ChannelArgs& args) {
   Helper* helper = new Helper(Ref(DEBUG_LOCATION, "Helper"));
   LoadBalancingPolicy::Args lb_policy_args;
   lb_policy_args.work_serializer = work_serializer();
   lb_policy_args.channel_control_helper =
       std::unique_ptr<ChannelControlHelper>(helper);
-  lb_policy_args.args = &args;
+  lb_policy_args.args = args;
   OrphanablePtr<LoadBalancingPolicy> lb_policy =
       CreateLoadBalancingPolicy(child_policy_name, std::move(lb_policy_args));
   if (GPR_UNLIKELY(lb_policy == nullptr)) {
-    gpr_log(GPR_ERROR, "could not create LB policy \"%s\"", child_policy_name);
+    gpr_log(GPR_ERROR, "could not create LB policy \"%s\"",
+            std::string(child_policy_name).c_str());
     return nullptr;
   }
   helper->set_child(lb_policy.get());
   if (GRPC_TRACE_FLAG_ENABLED(*tracer_)) {
     gpr_log(GPR_INFO,
             "[child_policy_handler %p] created new LB policy \"%s\" (%p)", this,
-            child_policy_name, lb_policy.get());
+            std::string(child_policy_name).c_str(), lb_policy.get());
   }
   channel_control_helper()->AddTraceEvent(
       ChannelControlHelper::TRACE_INFO,
@@ -303,12 +305,12 @@ OrphanablePtr<LoadBalancingPolicy> ChildPolicyHandler::CreateChildPolicy(
 bool ChildPolicyHandler::ConfigChangeRequiresNewPolicyInstance(
     LoadBalancingPolicy::Config* old_config,
     LoadBalancingPolicy::Config* new_config) const {
-  return strcmp(old_config->name(), new_config->name()) != 0;
+  return old_config->name() != new_config->name();
 }
 
 OrphanablePtr<LoadBalancingPolicy>
 ChildPolicyHandler::CreateLoadBalancingPolicy(
-    const char* name, LoadBalancingPolicy::Args args) const {
+    absl::string_view name, LoadBalancingPolicy::Args args) const {
   return LoadBalancingPolicyRegistry::CreateLoadBalancingPolicy(
       name, std::move(args));
 }

data/src/core/ext/filters/client_channel/lb_policy/child_policy_handler.h

@@ -16,17 +16,17 @@
 
 #ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_CHILD_POLICY_HANDLER_H
 #define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_CHILD_POLICY_HANDLER_H
-
 #include <grpc/support/port_platform.h>
 
 #include <utility>
 
-#include <grpc/impl/codegen/grpc_types.h>
+#include "absl/strings/string_view.h"
 
-#include "src/core/ext/filters/client_channel/lb_policy.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/load_balancing/lb_policy.h"
 
 namespace grpc_core {
 
@@ -41,7 +41,7 @@ class ChildPolicyHandler : public LoadBalancingPolicy {
   ChildPolicyHandler(Args args, TraceFlag* tracer)
       : LoadBalancingPolicy(std::move(args)), tracer_(tracer) {}
 
-  const char* name() const override { return "child_policy_handler"; }
+  absl::string_view name() const override { return "child_policy_handler"; }
 
   void UpdateLocked(UpdateArgs args) override;
   void ExitIdleLocked() override;
@@ -57,7 +57,7 @@ class ChildPolicyHandler : public LoadBalancingPolicy {
   // May be overridden by subclasses to avoid recursion when an LB
   // policy factory returns a ChildPolicyHandler.
   virtual OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
-      const char* name, LoadBalancingPolicy::Args args) const;
+      absl::string_view name, LoadBalancingPolicy::Args args) const;
 
  private:
   class Helper;
@@ -65,7 +65,7 @@ class ChildPolicyHandler : public LoadBalancingPolicy {
   void ShutdownLocked() override;
 
   OrphanablePtr<LoadBalancingPolicy> CreateChildPolicy(
-      const char* child_policy_name, const grpc_channel_args& args);
+      absl::string_view child_policy_name, const ChannelArgs& args);
 
   // Passed in from caller at construction time.
   TraceFlag* tracer_;