Offer grpc_slice_to_c_string to simplify some code

include/grpc/slice.h

@@ -157,6 +157,10 @@ GPRAPI int grpc_slice_is_equivalent(grpc_slice a, grpc_slice b);
  * as \a s */
 GPRAPI grpc_slice grpc_slice_dup(grpc_slice a);
 
+/* Return a copy of slice as a C string. Offers no protection against embedded
+   NULL's. Returned string must be freed with gpr_free. */
+GPRAPI char *grpc_slice_to_c_string(grpc_slice s);
+
 #ifdef __cplusplus
 }
 #endif

src/core/ext/lb_policy/grpclb/grpclb.c

@@ -1323,7 +1323,7 @@ static void lb_on_server_status_received(grpc_exec_ctx *exec_ctx, void *arg,
 
   if (grpc_lb_glb_trace) {
     char *status_details =
-        grpc_dump_slice(glb_policy->lb_call_status_details, GPR_DUMP_ASCII);
+        grpc_slice_to_c_string(glb_policy->lb_call_status_details);
     gpr_log(GPR_DEBUG,
             "Status from LB server received. Status = %d, Details = '%s', "
             "(call: %p)",

src/core/ext/resolver/sockaddr/sockaddr_resolver.c

@@ -182,7 +182,7 @@ static grpc_resolver *sockaddr_create(grpc_exec_ctx *exec_ctx,
   bool errors_found = false;
   for (size_t i = 0; i < addresses->num_addresses; i++) {
     grpc_uri ith_uri = *args->uri;
-    char *part_str = grpc_dump_slice(path_parts.slices[i], GPR_DUMP_ASCII);
+    char *part_str = grpc_slice_to_c_string(path_parts.slices[i]);
     ith_uri.path = part_str;
     if (!parse(&ith_uri, &addresses->addresses[i].address)) {
       errors_found = true; /* GPR_TRUE */

src/core/ext/transport/chttp2/transport/bin_decoder.c

@@ -178,7 +178,7 @@ grpc_slice grpc_chttp2_base64_decode(grpc_exec_ctx *exec_ctx,
   ctx.contains_tail = false;
 
   if (!grpc_base64_decode_partial(&ctx)) {
-    char *s = grpc_dump_slice(input, GPR_DUMP_ASCII);
+    char *s = grpc_slice_to_c_string(input);
     gpr_log(GPR_ERROR, "Base64 decoding failed, input string:\n%s\n", s);
     gpr_free(s);
     grpc_slice_unref_internal(exec_ctx, output);
@@ -224,7 +224,7 @@ grpc_slice grpc_chttp2_base64_decode_with_length(grpc_exec_ctx *exec_ctx,
   ctx.contains_tail = true;
 
   if (!grpc_base64_decode_partial(&ctx)) {
-    char *s = grpc_dump_slice(input, GPR_DUMP_ASCII);
+    char *s = grpc_slice_to_c_string(input);
     gpr_log(GPR_ERROR, "Base64 decoding failed, input string:\n%s\n", s);
     gpr_free(s);
     grpc_slice_unref_internal(exec_ctx, output);

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

@@ -983,8 +983,8 @@ static void log_metadata(const grpc_metadata_batch *md_batch, uint32_t id,
                          bool is_client, bool is_initial) {
   for (grpc_linked_mdelem *md = md_batch->list.head; md != md_batch->list.tail;
        md = md->next) {
-    char *key = grpc_dump_slice(GRPC_MDKEY(md->md), GPR_DUMP_ASCII);
-    char *value = grpc_dump_slice(GRPC_MDVALUE(md->md), GPR_DUMP_ASCII);
+    char *key = grpc_slice_to_c_string(GRPC_MDKEY(md->md));
+    char *value = grpc_slice_to_c_string(GRPC_MDVALUE(md->md));
     gpr_log(GPR_INFO, "HTTP:%d:%s:%s: %s: %s", id, is_initial ? "HDR" : "TRL",
             is_client ? "CLI" : "SVR", key, value);
     gpr_free(key);

src/core/ext/transport/chttp2/transport/hpack_encoder.c

@@ -397,8 +397,8 @@ static void hpack_enc(grpc_exec_ctx *exec_ctx, grpc_chttp2_hpack_compressor *c,
   }
 
   if (grpc_http_trace && !GRPC_MDELEM_IS_INTERNED(elem)) {
-    char *k = grpc_dump_slice(GRPC_MDKEY(elem), GPR_DUMP_ASCII);
-    char *v = grpc_dump_slice(GRPC_MDVALUE(elem), GPR_DUMP_ASCII);
+    char *k = grpc_slice_to_c_string(GRPC_MDKEY(elem));
+    char *v = grpc_slice_to_c_string(GRPC_MDVALUE(elem));
     gpr_log(
         GPR_DEBUG,
         "Encode: '%s: %s', elem_interned=%d [%d], k_interned=%d, v_interned=%d",

src/core/ext/transport/chttp2/transport/hpack_parser.c

@@ -674,8 +674,8 @@ static const uint8_t inverse_base64[256] = {
 static grpc_error *on_hdr(grpc_exec_ctx *exec_ctx, grpc_chttp2_hpack_parser *p,
                           grpc_mdelem md, int add_to_table) {
   if (grpc_http_trace && !GRPC_MDELEM_IS_INTERNED(md)) {
-    char *k = grpc_dump_slice(GRPC_MDKEY(md), GPR_DUMP_ASCII);
-    char *v = grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_ASCII);
+    char *k = grpc_slice_to_c_string(GRPC_MDKEY(md));
+    char *v = grpc_slice_to_c_string(GRPC_MDVALUE(md));
     gpr_log(
         GPR_DEBUG,
         "Decode: '%s: %s', elem_interned=%d [%d], k_interned=%d, v_interned=%d",

src/core/ext/transport/chttp2/transport/parsing.c

@@ -453,7 +453,7 @@ static void on_initial_header(grpc_exec_ctx *exec_ctx, void *tp,
   GPR_ASSERT(s != NULL);
 
   if (grpc_http_trace) {
-    char *key = grpc_dump_slice(GRPC_MDKEY(md), GPR_DUMP_ASCII);
+    char *key = grpc_slice_to_c_string(GRPC_MDKEY(md));
     char *value =
         grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_HEX | GPR_DUMP_ASCII);
     gpr_log(GPR_INFO, "HTTP:%d:HDR:%s: %s: %s", s->id,
@@ -475,7 +475,7 @@ static void on_initial_header(grpc_exec_ctx *exec_ctx, void *tp,
       /* not already parsed: parse it now, and store the result away */
       cached_timeout = gpr_malloc(sizeof(gpr_timespec));
       if (!grpc_http2_decode_timeout(GRPC_MDVALUE(md), cached_timeout)) {
-        char *val = grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_ASCII);
+        char *val = grpc_slice_to_c_string(GRPC_MDVALUE(md));
         gpr_log(GPR_ERROR, "Ignoring bad timeout value '%s'", val);
         gpr_free(val);
         *cached_timeout = gpr_inf_future(GPR_TIMESPAN);
@@ -525,7 +525,7 @@ static void on_trailing_header(grpc_exec_ctx *exec_ctx, void *tp,
   GPR_ASSERT(s != NULL);
 
   if (grpc_http_trace) {
-    char *key = grpc_dump_slice(GRPC_MDKEY(md), GPR_DUMP_ASCII);
+    char *key = grpc_slice_to_c_string(GRPC_MDKEY(md));
     char *value =
         grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_HEX | GPR_DUMP_ASCII);
     gpr_log(GPR_INFO, "HTTP:%d:TRL:%s: %s: %s", s->id,

src/core/ext/transport/cronet/transport/cronet_transport.c

@@ -626,8 +626,8 @@ static void convert_metadata_to_cronet_headers(
   while (num_headers < num_headers_available) {
     grpc_mdelem mdelem = curr->md;
     curr = curr->next;
-    char *key = grpc_dump_slice(GRPC_MDKEY(mdelem), GPR_DUMP_ASCII);
-    char *value = grpc_dump_slice(GRPC_MDVALUE(mdelem), GPR_DUMP_ASCII);
+    char *key = grpc_slice_to_c_string(GRPC_MDKEY(mdelem));
+    char *value = grpc_slice_to_c_string(GRPC_MDVALUE(mdelem));
     if (grpc_slice_eq(GRPC_MDKEY(mdelem), GRPC_MDSTR_SCHEME) ||
         grpc_slice_eq(GRPC_MDKEY(mdelem), GRPC_MDSTR_AUTHORITY)) {
       /* Cronet populates these fields on its own */

src/core/lib/channel/compress_filter.c

@@ -115,7 +115,7 @@ static grpc_error *process_send_initial_metadata(
         initial_metadata->idx.named.grpc_internal_encoding_request->md;
     if (!grpc_compression_algorithm_parse(GRPC_MDVALUE(md),
                                           &calld->compression_algorithm)) {
-      char *val = grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_ASCII);
+      char *val = grpc_slice_to_c_string(GRPC_MDVALUE(md));
       gpr_log(GPR_ERROR,
               "Invalid compression algorithm: '%s' (unknown). Ignoring.", val);
       gpr_free(val);
@@ -123,7 +123,7 @@ static grpc_error *process_send_initial_metadata(
     }
     if (!GPR_BITGET(channeld->enabled_algorithms_bitset,
                     calld->compression_algorithm)) {
-      char *val = grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_ASCII);
+      char *val = grpc_slice_to_c_string(GRPC_MDVALUE(md));
       gpr_log(GPR_ERROR,
               "Invalid compression algorithm: '%s' (previously disabled). "
               "Ignoring.",

src/core/lib/security/credentials/plugin/plugin_credentials.c

@@ -79,7 +79,7 @@ static void plugin_md_request_metadata_ready(void *request,
     grpc_credentials_md *md_array = NULL;
     for (i = 0; i < num_md; i++) {
       if (!grpc_header_key_is_legal(md[i].key)) {
-        char *key = grpc_dump_slice(md[i].key, GPR_DUMP_ASCII);
+        char *key = grpc_slice_to_c_string(md[i].key);
         gpr_log(GPR_ERROR, "Plugin added invalid metadata key: %s", key);
         gpr_free(key);
         seen_illegal_header = true;

src/core/lib/security/transport/client_auth_filter.c

@@ -134,7 +134,7 @@ static void on_credentials_metadata(grpc_exec_ctx *exec_ctx, void *user_data,
   grpc_error *error = GRPC_ERROR_NONE;
   for (i = 0; i < num_md; i++) {
     if (!grpc_header_key_is_legal(md_elems[i].key)) {
-      char *str = grpc_dump_slice(md_elems[i].key, GPR_DUMP_ASCII);
+      char *str = grpc_slice_to_c_string(md_elems[i].key);
       gpr_log(GPR_ERROR, "attempt to send invalid metadata key: %s", str);
       gpr_free(str);
     } else if (!grpc_is_binary_header(md_elems[i].key) &&
@@ -162,7 +162,7 @@ static void on_credentials_metadata(grpc_exec_ctx *exec_ctx, void *user_data,
 void build_auth_metadata_context(grpc_security_connector *sc,
                                  grpc_auth_context *auth_context,
                                  call_data *calld) {
-  char *service = grpc_dump_slice(calld->method, GPR_DUMP_ASCII);
+  char *service = grpc_slice_to_c_string(calld->method);
   char *last_slash = strrchr(service, '/');
   char *method_name = NULL;
   char *service_url = NULL;
@@ -178,7 +178,7 @@ void build_auth_metadata_context(grpc_security_connector *sc,
     method_name = gpr_strdup(last_slash + 1);
   }
   if (method_name == NULL) method_name = gpr_strdup("");
-  char *host = grpc_dump_slice(calld->host, GPR_DUMP_ASCII);
+  char *host = grpc_slice_to_c_string(calld->host);
   gpr_asprintf(&service_url, "%s://%s%s",
                sc->url_scheme == NULL ? "" : sc->url_scheme, host, service);
   calld->auth_md_context.service_url = service_url;
@@ -237,7 +237,7 @@ static void on_host_checked(grpc_exec_ctx *exec_ctx, void *user_data,
     send_security_metadata(exec_ctx, elem, &calld->op);
   } else {
     char *error_msg;
-    char *host = grpc_dump_slice(calld->host, GPR_DUMP_ASCII);
+    char *host = grpc_slice_to_c_string(calld->host);
     gpr_asprintf(&error_msg, "Invalid host %s set in :authority metadata.",
                  host);
     gpr_free(host);
@@ -297,7 +297,7 @@ static void auth_start_transport_op(grpc_exec_ctx *exec_ctx,
       }
     }
     if (calld->have_host) {
-      char *call_host = grpc_dump_slice(calld->host, GPR_DUMP_ASCII);
+      char *call_host = grpc_slice_to_c_string(calld->host);
       calld->op = *op; /* Copy op (originates from the caller's stack). */
       grpc_channel_security_connector_check_call_host(
           exec_ctx, chand->security_connector, call_host, chand->auth_context,

src/core/lib/slice/slice.c

@@ -41,6 +41,13 @@
 
 #include "src/core/lib/iomgr/exec_ctx.h"
 
+char *grpc_slice_to_c_string(grpc_slice slice) {
+  char *out = gpr_malloc(GRPC_SLICE_LENGTH(slice) + 1);
+  memcpy(out, GRPC_SLICE_START_PTR(slice), GRPC_SLICE_LENGTH(slice));
+  out[GRPC_SLICE_LENGTH(slice)] = 0;
+  return out;
+}
+
 grpc_slice grpc_empty_slice(void) {
   grpc_slice out;
   out.refcount = NULL;

src/core/lib/surface/call.c

@@ -532,7 +532,7 @@ static void set_encodings_accepted_by_peer(grpc_exec_ctx *exec_ctx,
       GPR_BITSET(&call->encodings_accepted_by_peer, algorithm);
     } else {
       char *accept_encoding_entry_str =
-          grpc_dump_slice(accept_encoding_entry_slice, GPR_DUMP_ASCII);
+          grpc_slice_to_c_string(accept_encoding_entry_slice);
       gpr_log(GPR_ERROR,
               "Invalid entry in accept encoding metadata: '%s'. Ignoring.",
               accept_encoding_entry_str);
@@ -599,7 +599,7 @@ static int prepare_application_metadata(
     grpc_linked_mdelem *l = (grpc_linked_mdelem *)&md->internal_data;
     GPR_ASSERT(sizeof(grpc_linked_mdelem) == sizeof(md->internal_data));
     if (!grpc_header_key_is_legal(md->key)) {
-      char *str = grpc_dump_slice(md->key, GPR_DUMP_ASCII);
+      char *str = grpc_slice_to_c_string(md->key);
       gpr_log(GPR_ERROR, "attempt to send invalid metadata key: %s", str);
       gpr_free(str);
       break;
@@ -860,7 +860,7 @@ static grpc_compression_algorithm decode_compression(grpc_mdelem md) {
   grpc_compression_algorithm algorithm =
       grpc_compression_algorithm_from_slice(GRPC_MDVALUE(md));
   if (algorithm == GRPC_COMPRESS_ALGORITHMS_COUNT) {
-    char *md_c_str = grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_ASCII);
+    char *md_c_str = grpc_slice_to_c_string(GRPC_MDVALUE(md));
     gpr_log(GPR_ERROR,
             "Invalid incoming compression algorithm: '%s'. Interpreting "
             "incoming data as uncompressed.",

src/core/lib/surface/call_log_batch.c

@@ -46,7 +46,7 @@ static void add_metadata(gpr_strvec *b, const grpc_metadata *md, size_t count) {
   }
   for (i = 0; i < count; i++) {
     gpr_strvec_add(b, gpr_strdup("\nkey="));
-    gpr_strvec_add(b, grpc_dump_slice(md[i].key, GPR_DUMP_ASCII));
+    gpr_strvec_add(b, grpc_slice_to_c_string(md[i].key));
 
     gpr_strvec_add(b, gpr_strdup(" value="));
     gpr_strvec_add(b,

src/core/lib/transport/metadata.c

@@ -161,8 +161,8 @@ static int is_mdelem_static(grpc_mdelem e) {
 static void ref_md_locked(mdtab_shard *shard,
                           interned_metadata *md DEBUG_ARGS) {
 #ifdef GRPC_METADATA_REFCOUNT_DEBUG
-  char *key_str = grpc_dump_slice(md->key, GPR_DUMP_ASCII);
-  char *value_str = grpc_dump_slice(md->value, GPR_DUMP_ASCII);
+  char *key_str = grpc_slice_to_c_string(md->key);
+  char *value_str = grpc_slice_to_c_string(md->value);
   gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
           "ELM   REF:%p:%zu->%zu: '%s' = '%s'", (void *)md,
           gpr_atm_no_barrier_load(&md->refcnt),
@@ -261,8 +261,8 @@ grpc_mdelem grpc_mdelem_create(
     allocated->value = grpc_slice_ref_internal(value);
     gpr_atm_rel_store(&allocated->refcnt, 1);
 #ifdef GRPC_METADATA_REFCOUNT_DEBUG
-    char *key_str = grpc_dump_slice(allocated->key, GPR_DUMP_ASCII);
-    char *value_str = grpc_dump_slice(allocated->value, GPR_DUMP_ASCII);
+    char *key_str = grpc_slice_to_c_string(allocated->key);
+    char *value_str = grpc_slice_to_c_string(allocated->value);
     gpr_log(GPR_DEBUG, "ELM ALLOC:%p:%zu: '%s' = '%s'", (void *)allocated,
             gpr_atm_no_barrier_load(&allocated->refcnt), key_str, value_str);
     gpr_free(key_str);
@@ -312,8 +312,8 @@ grpc_mdelem grpc_mdelem_create(
   shard->elems[idx] = md;
   gpr_mu_init(&md->mu_user_data);
 #ifdef GRPC_METADATA_REFCOUNT_DEBUG
-  char *key_str = grpc_dump_slice(md->key, GPR_DUMP_ASCII);
-  char *value_str = grpc_dump_slice(md->value, GPR_DUMP_ASCII);
+  char *key_str = grpc_slice_to_c_string(md->key);
+  char *value_str = grpc_slice_to_c_string(md->value);
   gpr_log(GPR_DEBUG, "ELM   NEW:%p:%zu: '%s' = '%s'", (void *)md,
           gpr_atm_no_barrier_load(&md->refcnt), key_str, value_str);
   gpr_free(key_str);
@@ -374,8 +374,8 @@ grpc_mdelem grpc_mdelem_ref(grpc_mdelem gmd DEBUG_ARGS) {
     case GRPC_MDELEM_STORAGE_INTERNED: {
       interned_metadata *md = (interned_metadata *)GRPC_MDELEM_DATA(gmd);
 #ifdef GRPC_METADATA_REFCOUNT_DEBUG
-      char *key_str = grpc_dump_slice(md->key, GPR_DUMP_ASCII);
-      char *value_str = grpc_dump_slice(md->value, GPR_DUMP_ASCII);
+      char *key_str = grpc_slice_to_c_string(md->key);
+      char *value_str = grpc_slice_to_c_string(md->value);
       gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
               "ELM   REF:%p:%zu->%zu: '%s' = '%s'", (void *)md,
               gpr_atm_no_barrier_load(&md->refcnt),
@@ -394,8 +394,8 @@ grpc_mdelem grpc_mdelem_ref(grpc_mdelem gmd DEBUG_ARGS) {
     case GRPC_MDELEM_STORAGE_ALLOCATED: {
       allocated_metadata *md = (allocated_metadata *)GRPC_MDELEM_DATA(gmd);
 #ifdef GRPC_METADATA_REFCOUNT_DEBUG
-      char *key_str = grpc_dump_slice(md->key, GPR_DUMP_ASCII);
-      char *value_str = grpc_dump_slice(md->value, GPR_DUMP_ASCII);
+      char *key_str = grpc_slice_to_c_string(md->key);
+      char *value_str = grpc_slice_to_c_string(md->value);
       gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
               "ELM   REF:%p:%zu->%zu: '%s' = '%s'", (void *)md,
               gpr_atm_no_barrier_load(&md->refcnt),
@@ -422,8 +422,8 @@ void grpc_mdelem_unref(grpc_exec_ctx *exec_ctx, grpc_mdelem gmd DEBUG_ARGS) {
     case GRPC_MDELEM_STORAGE_INTERNED: {
       interned_metadata *md = (interned_metadata *)GRPC_MDELEM_DATA(gmd);
 #ifdef GRPC_METADATA_REFCOUNT_DEBUG
-      char *key_str = grpc_dump_slice(md->key, GPR_DUMP_ASCII);
-      char *value_str = grpc_dump_slice(md->value, GPR_DUMP_ASCII);
+      char *key_str = grpc_slice_to_c_string(md->key);
+      char *value_str = grpc_slice_to_c_string(md->value);
       gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
               "ELM UNREF:%p:%zu->%zu: '%s' = '%s'", (void *)md,
               gpr_atm_no_barrier_load(&md->refcnt),
@@ -446,8 +446,8 @@ void grpc_mdelem_unref(grpc_exec_ctx *exec_ctx, grpc_mdelem gmd DEBUG_ARGS) {
     case GRPC_MDELEM_STORAGE_ALLOCATED: {
       allocated_metadata *md = (allocated_metadata *)GRPC_MDELEM_DATA(gmd);
 #ifdef GRPC_METADATA_REFCOUNT_DEBUG
-      char *key_str = grpc_dump_slice(md->key, GPR_DUMP_ASCII);
-      char *value_str = grpc_dump_slice(md->value, GPR_DUMP_ASCII);
+      char *key_str = grpc_slice_to_c_string(md->key);
+      char *value_str = grpc_slice_to_c_string(md->value);
       gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
               "ELM UNREF:%p:%zu->%zu: '%s' = '%s'", (void *)md,
               gpr_atm_no_barrier_load(&md->refcnt),

src/core/lib/transport/metadata_batch.c

@@ -99,8 +99,8 @@ void grpc_metadata_batch_destroy(grpc_exec_ctx *exec_ctx,
 }
 
 grpc_error *grpc_attach_md_to_error(grpc_error *src, grpc_mdelem md) {
-  char *k = grpc_dump_slice(GRPC_MDKEY(md), GPR_DUMP_ASCII);
-  char *v = grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_ASCII);
+  char *k = grpc_slice_to_c_string(GRPC_MDKEY(md));
+  char *v = grpc_slice_to_c_string(GRPC_MDVALUE(md));
   grpc_error *out = grpc_error_set_str(
       grpc_error_set_str(src, GRPC_ERROR_STR_KEY, k), GRPC_ERROR_STR_VALUE, v);
   gpr_free(k);

src/core/lib/transport/service_config.c

@@ -237,7 +237,7 @@ void* grpc_method_config_table_get(grpc_exec_ctx* exec_ctx,
   // If we didn't find a match for the path, try looking for a wildcard
   // entry (i.e., change "/service/method" to "/service/*").
   if (value == NULL) {
-    char* path_str = grpc_dump_slice(path, GPR_DUMP_ASCII);
+    char* path_str = grpc_slice_to_c_string(path);
     const char* sep = strrchr(path_str, '/') + 1;
     const size_t len = (size_t)(sep - path_str);
     char* buf = gpr_malloc(len + 2);  // '*' and NUL

src/core/lib/transport/transport.c

@@ -224,7 +224,7 @@ void grpc_transport_stream_op_add_cancellation_with_message(
   }
   grpc_error *error;
   if (optional_message != NULL) {
-    char *msg = grpc_dump_slice(*optional_message, GPR_DUMP_ASCII);
+    char *msg = grpc_slice_to_c_string(*optional_message);
     error = grpc_error_set_str(GRPC_ERROR_CREATE(msg),
                                GRPC_ERROR_STR_GRPC_MESSAGE, msg);
     gpr_free(msg);
@@ -250,7 +250,7 @@ void grpc_transport_stream_op_add_close(grpc_exec_ctx *exec_ctx,
   }
   grpc_error *error;
   if (optional_message != NULL) {
-    char *msg = grpc_dump_slice(*optional_message, GPR_DUMP_ASCII);
+    char *msg = grpc_slice_to_c_string(*optional_message);
     error = grpc_error_set_str(GRPC_ERROR_CREATE(msg),
                                GRPC_ERROR_STR_GRPC_MESSAGE, msg);
     gpr_free(msg);

src/php/ext/grpc/call.c

@@ -475,7 +475,7 @@ PHP_METHOD(Call, startBatch) {
 #endif
       PHP_GRPC_DELREF(array);
       add_property_long(recv_status, "code", status);
-      char *status_details_text = grpc_dump_slice(status_details, GPR_DUMP_ASCII);
+      char *status_details_text = grpc_slice_to_c_string(status_details);
       php_grpc_add_property_string(recv_status, "details", status_details_text,
                                    true);
       gpr_free(status_details_text);

test/core/client_channel/set_initial_connect_string_test.c

@@ -209,7 +209,7 @@ static void match_initial_magic_string(grpc_slice_buffer *buffer) {
   GPR_ASSERT(buffer->length >= magic_length);
   for (i = 0, j = 0; i < state.incoming_buffer.count && j < magic_length; i++) {
     char *dump =
-        grpc_dump_slice(state.incoming_buffer.slices[i], GPR_DUMP_ASCII);
+        grpc_slice_to_c_string(state.incoming_buffer.slices[i]);
     cmp_length = GPR_MIN(strlen(dump), magic_length - j);
     GPR_ASSERT(strncmp(dump, magic_connect_string + j, cmp_length) == 0);
     j += cmp_length;

test/core/end2end/dualstack_socket_test.c

@@ -134,7 +134,7 @@ void test_connect(const char *server_host, const char *client_host, int port,
     grpc_slice_split(uri_slice, ",", &uri_parts);
     hosts_with_port = gpr_malloc(sizeof(char *) * uri_parts.count);
     for (i = 0; i < uri_parts.count; i++) {
-      char *uri_part_str = grpc_dump_slice(uri_parts.slices[i], GPR_DUMP_ASCII);
+      char *uri_part_str = grpc_slice_to_c_string(uri_parts.slices[i]);
       gpr_asprintf(&hosts_with_port[i], "%s:%d", uri_part_str, port);
       gpr_free(uri_part_str);
     }

test/core/end2end/fake_resolver.c

@@ -165,7 +165,7 @@ static grpc_resolver* fake_resolver_create(grpc_exec_ctx* exec_ctx,
   bool errors_found = false;
   for (size_t i = 0; i < addresses->num_addresses; i++) {
     grpc_uri ith_uri = *args->uri;
-    char* part_str = grpc_dump_slice(path_parts.slices[i], GPR_DUMP_ASCII);
+    char* part_str = grpc_slice_to_c_string(path_parts.slices[i]);
     ith_uri.path = part_str;
     if (!parse_ipv4(&ith_uri, &addresses->addresses[i].address)) {
       errors_found = true;

test/core/security/print_google_default_creds_token.c

@@ -63,7 +63,7 @@ static void on_metadata_response(grpc_exec_ctx *exec_ctx, void *user_data,
   } else {
     char *token;
     GPR_ASSERT(num_md == 1);
-    token = grpc_dump_slice(md_elems[0].value, GPR_DUMP_ASCII);
+    token = grpc_slice_to_c_string(md_elems[0].value);
     printf("\nGot token: %s\n\n", token);
     gpr_free(token);
   }

test/core/security/security_connector_test.c

@@ -370,7 +370,7 @@ static void test_default_ssl_roots(void) {
   gpr_setenv(GRPC_DEFAULT_SSL_ROOTS_FILE_PATH_ENV_VAR, "");
   grpc_set_ssl_roots_override_callback(override_roots_success);
   grpc_slice roots = grpc_get_default_ssl_roots_for_testing();
-  char *roots_contents = grpc_dump_slice(roots, GPR_DUMP_ASCII);
+  char *roots_contents = grpc_slice_to_c_string(roots);
   grpc_slice_unref(roots);
   GPR_ASSERT(strcmp(roots_contents, roots_for_override_api) == 0);
   gpr_free(roots_contents);
@@ -379,7 +379,7 @@ static void test_default_ssl_roots(void) {
      instead. */
   gpr_setenv(GRPC_DEFAULT_SSL_ROOTS_FILE_PATH_ENV_VAR, roots_env_var_file_path);
   roots = grpc_get_default_ssl_roots_for_testing();
-  roots_contents = grpc_dump_slice(roots, GPR_DUMP_ASCII);
+  roots_contents = grpc_slice_to_c_string(roots);
   grpc_slice_unref(roots);
   GPR_ASSERT(strcmp(roots_contents, roots_for_env_var) == 0);
   gpr_free(roots_contents);
@@ -388,7 +388,7 @@ static void test_default_ssl_roots(void) {
      the api. */
   gpr_setenv(GRPC_DEFAULT_SSL_ROOTS_FILE_PATH_ENV_VAR, "");
   roots = grpc_get_default_ssl_roots_for_testing();
-  roots_contents = grpc_dump_slice(roots, GPR_DUMP_ASCII);
+  roots_contents = grpc_slice_to_c_string(roots);
   grpc_slice_unref(roots);
   GPR_ASSERT(strcmp(roots_contents, roots_for_override_api) == 0);
   gpr_free(roots_contents);