Clean out all GRPC_ARG_STRING:

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

@@ -669,21 +669,18 @@ static grpc_error* cc_init_channel_elem(grpc_channel_element* elem,
   chand->client_channel_factory = client_channel_factory;
   // Get server name to resolve, using proxy mapper if needed.
   arg = grpc_channel_args_find(args->channel_args, GRPC_ARG_SERVER_URI);
-  if (arg == nullptr) {
+  char* server_uri = grpc_channel_arg_get_string(arg);
+  if (server_uri == nullptr) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "Missing server uri in args for client channel filter");
-  }
-  if (arg->type != GRPC_ARG_STRING) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "server uri arg must be a string");
+        "Missing or malformed server uri in args for client channel filter");
   }
   char* proxy_name = nullptr;
   grpc_channel_args* new_args = nullptr;
-  grpc_proxy_mappers_map_name(arg->value.string, args->channel_args,
-                              &proxy_name, &new_args);
+  grpc_proxy_mappers_map_name(server_uri, args->channel_args, &proxy_name,
+                              &new_args);
   // Instantiate resolver.
   chand->resolver = grpc_core::ResolverRegistry::CreateResolver(
-      proxy_name != nullptr ? proxy_name : arg->value.string,
+      proxy_name != nullptr ? proxy_name : server_uri,
       new_args != nullptr ? new_args : args->channel_args,
       chand->interested_parties, chand->combiner);
   if (proxy_name != nullptr) gpr_free(proxy_name);

src/core/ext/filters/http/client/http_client_filter.cc

@@ -23,6 +23,7 @@
 #include <stdint.h>
 #include <string.h>
 #include "src/core/ext/filters/http/client/http_client_filter.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/profiling/timers.h"
@@ -435,20 +436,18 @@ static void destroy_call_elem(grpc_call_element* elem,
                               const grpc_call_final_info* final_info,
                               grpc_closure* ignored) {}
 
-static grpc_mdelem scheme_from_args(const grpc_channel_args* args) {
-  unsigned i;
-  size_t j;
+static grpc_mdelem scheme_from_args(const grpc_channel_args* channel_args) {
+  size_t i;
   grpc_mdelem valid_schemes[] = {GRPC_MDELEM_SCHEME_HTTP,
                                  GRPC_MDELEM_SCHEME_HTTPS};
-  if (args != nullptr) {
-    for (i = 0; i < args->num_args; ++i) {
-      if (args->args[i].type == GRPC_ARG_STRING &&
-          strcmp(args->args[i].key, GRPC_ARG_HTTP2_SCHEME) == 0) {
-        for (j = 0; j < GPR_ARRAY_SIZE(valid_schemes); j++) {
-          if (0 == grpc_slice_str_cmp(GRPC_MDVALUE(valid_schemes[j]),
-                                      args->args[i].value.string)) {
-            return valid_schemes[j];
-          }
+  if (channel_args != nullptr) {
+    const grpc_arg* arg =
+        grpc_channel_args_find(channel_args, GRPC_ARG_HTTP2_SCHEME);
+    char* scheme = grpc_channel_arg_get_string(arg);
+    if (scheme != nullptr) {
+      for (i = 0; i < GPR_ARRAY_SIZE(valid_schemes); i++) {
+        if (0 == grpc_slice_str_cmp(GRPC_MDVALUE(valid_schemes[i]), scheme)) {
+          return valid_schemes[i];
         }
       }
     }
@@ -475,24 +474,19 @@ static size_t max_payload_size_from_args(const grpc_channel_args* args) {
 static grpc_slice user_agent_from_args(const grpc_channel_args* args,
                                        const char* transport_name) {
   gpr_strvec v;
-  size_t i;
   int is_first = 1;
   char* tmp;
   grpc_slice result;
 
   gpr_strvec_init(&v);
 
-  for (i = 0; args && i < args->num_args; i++) {
-    if (0 == strcmp(args->args[i].key, GRPC_ARG_PRIMARY_USER_AGENT_STRING)) {
-      if (args->args[i].type != GRPC_ARG_STRING) {
-        gpr_log(GPR_ERROR, "Channel argument '%s' should be a string",
-                GRPC_ARG_PRIMARY_USER_AGENT_STRING);
-      } else {
-        if (!is_first) gpr_strvec_add(&v, gpr_strdup(" "));
-        is_first = 0;
-        gpr_strvec_add(&v, gpr_strdup(args->args[i].value.string));
-      }
-    }
+  const grpc_arg* arg =
+      grpc_channel_args_find(args, GRPC_ARG_PRIMARY_USER_AGENT_STRING);
+  char* user_agent_str = grpc_channel_arg_get_string(arg);
+  if (user_agent_str != nullptr) {
+    if (!is_first) gpr_strvec_add(&v, gpr_strdup(" "));
+    is_first = 0;
+    gpr_strvec_add(&v, gpr_strdup(user_agent_str));
   }
 
   gpr_asprintf(&tmp, "%sgrpc-c/%s (%s; %s; %s)", is_first ? "" : " ",
@@ -501,17 +495,11 @@ static grpc_slice user_agent_from_args(const grpc_channel_args* args,
   is_first = 0;
   gpr_strvec_add(&v, tmp);
 
-  for (i = 0; args && i < args->num_args; i++) {
-    if (0 == strcmp(args->args[i].key, GRPC_ARG_SECONDARY_USER_AGENT_STRING)) {
-      if (args->args[i].type != GRPC_ARG_STRING) {
-        gpr_log(GPR_ERROR, "Channel argument '%s' should be a string",
-                GRPC_ARG_SECONDARY_USER_AGENT_STRING);
-      } else {
-        if (!is_first) gpr_strvec_add(&v, gpr_strdup(" "));
-        is_first = 0;
-        gpr_strvec_add(&v, gpr_strdup(args->args[i].value.string));
-      }
-    }
+  arg = grpc_channel_args_find(args, GRPC_ARG_SECONDARY_USER_AGENT_STRING);
+  user_agent_str = grpc_channel_arg_get_string(arg);
+  if (user_agent_str != nullptr) {
+    gpr_strvec_add(&v, gpr_strdup(" "));
+    gpr_strvec_add(&v, gpr_strdup(user_agent_str));
   }
 
   tmp = gpr_strvec_flatten(&v, nullptr);

src/core/ext/transport/chttp2/transport/chttp2_transport.cc

@@ -447,20 +447,19 @@ static void init_transport(grpc_chttp2_transport* t,
             grpc_channel_arg_get_integer(&channel_args->args[i], {0, 0, 1}));
       } else if (0 == strcmp(channel_args->args[i].key,
                              GRPC_ARG_OPTIMIZATION_TARGET)) {
-        if (channel_args->args[i].type != GRPC_ARG_STRING) {
-          gpr_log(GPR_ERROR, "%s should be a string",
-                  GRPC_ARG_OPTIMIZATION_TARGET);
-        } else if (0 == strcmp(channel_args->args[i].value.string, "blend")) {
+        char* opt_target_str =
+            grpc_channel_arg_get_string(&channel_args->args[i]);
+        if (opt_target_str == nullptr) {
+          gpr_log(GPR_ERROR, "null/missing value opt target, assuming 'blend'");
+        } else if (0 == strcmp(opt_target_str, "blend")) {
           t->opt_target = GRPC_CHTTP2_OPTIMIZE_FOR_LATENCY;
-        } else if (0 == strcmp(channel_args->args[i].value.string, "latency")) {
+        } else if (0 == strcmp(opt_target_str, "latency")) {
           t->opt_target = GRPC_CHTTP2_OPTIMIZE_FOR_LATENCY;
-        } else if (0 ==
-                   strcmp(channel_args->args[i].value.string, "throughput")) {
+        } else if (0 == strcmp(opt_target_str, "throughput")) {
           t->opt_target = GRPC_CHTTP2_OPTIMIZE_FOR_THROUGHPUT;
         } else {
           gpr_log(GPR_ERROR, "%s value '%s' unknown, assuming 'blend'",
-                  GRPC_ARG_OPTIMIZATION_TARGET,
-                  channel_args->args[i].value.string);
+                  GRPC_ARG_OPTIMIZATION_TARGET, opt_target_str);
         }
       } else {
         static const struct {

src/core/ext/transport/inproc/inproc_transport.cc

@@ -1204,10 +1204,9 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
 
   // Add a default authority channel argument for the client
 
-  grpc_arg default_authority_arg;
-  default_authority_arg.type = GRPC_ARG_STRING;
-  default_authority_arg.key = (char*)GRPC_ARG_DEFAULT_AUTHORITY;
-  default_authority_arg.value.string = (char*)"inproc.authority";
+  grpc_arg default_authority_arg = grpc_channel_arg_string_create(
+      const_cast<char*>(GRPC_ARG_DEFAULT_AUTHORITY),
+      const_cast<char*>("inproc.authority"));
   grpc_channel_args* client_args =
       grpc_channel_args_copy_and_add(args, &default_authority_arg, 1);
 

tools/run_tests/sanity/check_channel_arg_usage.py

@@ -29,6 +29,7 @@ _EXCEPTIONS = set([
 
 _BANNED = set([
     "GRPC_ARG_POINTER",
+    "GRPC_ARG_STRING",
 ])
 
 errors = 0