Merge branch 'master' into node_electron_build

11 files changed, 49 insertions, 968 deletions

diff --git a/src/core/lib/support/backoff.c b/src/core/lib/support/backoff.c
index e89ef47220..0612472712 100644
--- a/src/core/lib/support/backoff.c
+++ b/src/core/lib/support/backoff.c
@@ -35,8 +35,10 @@
 
 #include <grpc/support/useful.h>
 
-void gpr_backoff_init(gpr_backoff *backoff, double multiplier, double jitter,
+void gpr_backoff_init(gpr_backoff *backoff, int64_t initial_connect_timeout,
+                      double multiplier, double jitter,
                       int64_t min_timeout_millis, int64_t max_timeout_millis) {
+  backoff->initial_connect_timeout = initial_connect_timeout;
   backoff->multiplier = multiplier;
   backoff->jitter = jitter;
   backoff->min_timeout_millis = min_timeout_millis;
@@ -45,9 +47,10 @@ void gpr_backoff_init(gpr_backoff *backoff, double multiplier, double jitter,
 }
 
 gpr_timespec gpr_backoff_begin(gpr_backoff *backoff, gpr_timespec now) {
-  backoff->current_timeout_millis = backoff->min_timeout_millis;
-  return gpr_time_add(
-      now, gpr_time_from_millis(backoff->current_timeout_millis, GPR_TIMESPAN));
+  backoff->current_timeout_millis = backoff->initial_connect_timeout;
+  const int64_t first_timeout =
+      GPR_MAX(backoff->current_timeout_millis, backoff->min_timeout_millis);
+  return gpr_time_add(now, gpr_time_from_millis(first_timeout, GPR_TIMESPAN));
 }
 
 /* Generate a random number between 0 and 1. */
@@ -57,20 +60,28 @@ static double generate_uniform_random_number(uint32_t *rng_state) {
 }
 
 gpr_timespec gpr_backoff_step(gpr_backoff *backoff, gpr_timespec now) {
-  double new_timeout_millis =
+  const double new_timeout_millis =
       backoff->multiplier * (double)backoff->current_timeout_millis;
-  double jitter_range = backoff->jitter * new_timeout_millis;
-  double jitter =
+  backoff->current_timeout_millis =
+      GPR_MIN((int64_t)new_timeout_millis, backoff->max_timeout_millis);
+
+  const double jitter_range_width = backoff->jitter * new_timeout_millis;
+  const double jitter =
       (2 * generate_uniform_random_number(&backoff->rng_state) - 1) *
-      jitter_range;
+      jitter_range_width;
+
   backoff->current_timeout_millis =
-      GPR_CLAMP((int64_t)(new_timeout_millis + jitter),
-                backoff->min_timeout_millis, backoff->max_timeout_millis);
-  return gpr_time_add(
+      (int64_t)((double)(backoff->current_timeout_millis) + jitter);
+
+  const gpr_timespec current_deadline = gpr_time_add(
       now, gpr_time_from_millis(backoff->current_timeout_millis, GPR_TIMESPAN));
+
+  const gpr_timespec min_deadline = gpr_time_add(
+      now, gpr_time_from_millis(backoff->min_timeout_millis, GPR_TIMESPAN));
+
+  return gpr_time_max(current_deadline, min_deadline);
 }
 
 void gpr_backoff_reset(gpr_backoff *backoff) {
-  // forces step() to return a timeout of min_timeout_millis
-  backoff->current_timeout_millis = 0;
+  backoff->current_timeout_millis = backoff->initial_connect_timeout;
 }
diff --git a/src/core/lib/support/backoff.h b/src/core/lib/support/backoff.h
index 6d40c15546..5e9b740824 100644
--- a/src/core/lib/support/backoff.h
+++ b/src/core/lib/support/backoff.h
@@ -37,7 +37,9 @@
 #include <grpc/support/time.h>
 
 typedef struct {
-  /// const: multiplier between retry attempts
+  /// const:  how long to wait after the first failure before retrying
+  int64_t initial_connect_timeout;
+  /// const: factor with which to multiply backoff after a failed retry
   double multiplier;
   /// const: amount to randomize backoffs
   double jitter;
@@ -54,7 +56,8 @@ typedef struct {
 } gpr_backoff;
 
 /// Initialize backoff machinery - does not need to be destroyed
-void gpr_backoff_init(gpr_backoff *backoff, double multiplier, double jitter,
+void gpr_backoff_init(gpr_backoff *backoff, int64_t initial_connect_timeout,
+                      double multiplier, double jitter,
                       int64_t min_timeout_millis, int64_t max_timeout_millis);
 
 /// Begin retry loop: returns a timespec for the NEXT retry
diff --git a/src/core/lib/support/env.h b/src/core/lib/support/env.h
index ec3959bc6e..6ada5d9390 100644
--- a/src/core/lib/support/env.h
+++ b/src/core/lib/support/env.h
@@ -36,8 +36,6 @@
 
 #include <stdio.h>
 
-#include <grpc/support/slice.h>
-
 #ifdef __cplusplus
 extern "C" {
 #endif
diff --git a/src/core/lib/support/percent_encoding.c b/src/core/lib/support/percent_encoding.c
deleted file mode 100644
index 3c19f264f9..0000000000
--- a/src/core/lib/support/percent_encoding.c
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
- *
- * Copyright 2016, Google Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#include "src/core/lib/support/percent_encoding.h"
-
-#include <grpc/support/log.h>
-
-const uint8_t gpr_url_percent_encoding_unreserved_bytes[256 / 8] = {
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xff, 0x03, 0xfe, 0xff, 0xff,
-    0x87, 0xfe, 0xff, 0xff, 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-const uint8_t gpr_compatible_percent_encoding_unreserved_bytes[256 / 8] = {
-    0x00, 0x00, 0x00, 0x00, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-
-static bool is_unreserved_character(uint8_t c,
-                                    const uint8_t *unreserved_bytes) {
-  return ((unreserved_bytes[c / 8] >> (c % 8)) & 1) != 0;
-}
-
-gpr_slice gpr_percent_encode_slice(gpr_slice slice,
-                                   const uint8_t *unreserved_bytes) {
-  static const uint8_t hex[] = "0123456789ABCDEF";
-
-  // first pass: count the number of bytes needed to output this string
-  size_t output_length = 0;
-  const uint8_t *slice_start = GPR_SLICE_START_PTR(slice);
-  const uint8_t *slice_end = GPR_SLICE_END_PTR(slice);
-  const uint8_t *p;
-  bool any_reserved_bytes = false;
-  for (p = slice_start; p < slice_end; p++) {
-    bool unres = is_unreserved_character(*p, unreserved_bytes);
-    output_length += unres ? 1 : 3;
-    any_reserved_bytes |= !unres;
-  }
-  // no unreserved bytes: return the string unmodified
-  if (!any_reserved_bytes) {
-    return gpr_slice_ref(slice);
-  }
-  // second pass: actually encode
-  gpr_slice out = gpr_slice_malloc(output_length);
-  uint8_t *q = GPR_SLICE_START_PTR(out);
-  for (p = slice_start; p < slice_end; p++) {
-    if (is_unreserved_character(*p, unreserved_bytes)) {
-      *q++ = *p;
-    } else {
-      *q++ = '%';
-      *q++ = hex[*p >> 4];
-      *q++ = hex[*p & 15];
-    }
-  }
-  GPR_ASSERT(q == GPR_SLICE_END_PTR(out));
-  return out;
-}
-
-static bool valid_hex(const uint8_t *p, const uint8_t *end) {
-  if (p >= end) return false;
-  return (*p >= '0' && *p <= '9') || (*p >= 'a' && *p <= 'f') ||
-         (*p >= 'A' && *p <= 'F');
-}
-
-static uint8_t dehex(uint8_t c) {
-  if (c >= '0' && c <= '9') return (uint8_t)(c - '0');
-  if (c >= 'A' && c <= 'F') return (uint8_t)(c - 'A' + 10);
-  if (c >= 'a' && c <= 'f') return (uint8_t)(c - 'a' + 10);
-  GPR_UNREACHABLE_CODE(return 255);
-}
-
-bool gpr_strict_percent_decode_slice(gpr_slice slice_in,
-                                     const uint8_t *unreserved_bytes,
-                                     gpr_slice *slice_out) {
-  const uint8_t *p = GPR_SLICE_START_PTR(slice_in);
-  const uint8_t *in_end = GPR_SLICE_END_PTR(slice_in);
-  size_t out_length = 0;
-  bool any_percent_encoded_stuff = false;
-  while (p != in_end) {
-    if (*p == '%') {
-      if (!valid_hex(++p, in_end)) return false;
-      if (!valid_hex(++p, in_end)) return false;
-      p++;
-      out_length++;
-      any_percent_encoded_stuff = true;
-    } else if (is_unreserved_character(*p, unreserved_bytes)) {
-      p++;
-      out_length++;
-    } else {
-      return false;
-    }
-  }
-  if (!any_percent_encoded_stuff) {
-    *slice_out = gpr_slice_ref(slice_in);
-    return true;
-  }
-  p = GPR_SLICE_START_PTR(slice_in);
-  *slice_out = gpr_slice_malloc(out_length);
-  uint8_t *q = GPR_SLICE_START_PTR(*slice_out);
-  while (p != in_end) {
-    if (*p == '%') {
-      *q++ = (uint8_t)(dehex(p[1]) << 4) | (dehex(p[2]));
-      p += 3;
-    } else {
-      *q++ = *p++;
-    }
-  }
-  GPR_ASSERT(q == GPR_SLICE_END_PTR(*slice_out));
-  return true;
-}
-
-gpr_slice gpr_permissive_percent_decode_slice(gpr_slice slice_in) {
-  const uint8_t *p = GPR_SLICE_START_PTR(slice_in);
-  const uint8_t *in_end = GPR_SLICE_END_PTR(slice_in);
-  size_t out_length = 0;
-  bool any_percent_encoded_stuff = false;
-  while (p != in_end) {
-    if (*p == '%') {
-      if (!valid_hex(p + 1, in_end) || !valid_hex(p + 2, in_end)) {
-        p++;
-        out_length++;
-      } else {
-        p += 3;
-        out_length++;
-        any_percent_encoded_stuff = true;
-      }
-    } else {
-      p++;
-      out_length++;
-    }
-  }
-  if (!any_percent_encoded_stuff) {
-    return gpr_slice_ref(slice_in);
-  }
-  p = GPR_SLICE_START_PTR(slice_in);
-  gpr_slice out = gpr_slice_malloc(out_length);
-  uint8_t *q = GPR_SLICE_START_PTR(out);
-  while (p != in_end) {
-    if (*p == '%') {
-      if (!valid_hex(p + 1, in_end) || !valid_hex(p + 2, in_end)) {
-        *q++ = *p++;
-      } else {
-        *q++ = (uint8_t)(dehex(p[1]) << 4) | (dehex(p[2]));
-        p += 3;
-      }
-    } else {
-      *q++ = *p++;
-    }
-  }
-  GPR_ASSERT(q == GPR_SLICE_END_PTR(out));
-  return out;
-}
diff --git a/src/core/lib/support/percent_encoding.h b/src/core/lib/support/percent_encoding.h
deleted file mode 100644
index 000bf14ede..0000000000
--- a/src/core/lib/support/percent_encoding.h
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- *
- * Copyright 2016, Google Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef GRPC_CORE_LIB_SUPPORT_PERCENT_ENCODING_H
-#define GRPC_CORE_LIB_SUPPORT_PERCENT_ENCODING_H
-
-/* Percent encoding and decoding of slices.
-   Transforms arbitrary strings into safe-for-transmission strings by using
-   variants of percent encoding (RFC 3986).
-   Two major variants are supplied: one that strictly matches URL encoding,
-     and another which applies percent encoding only to non-http2 header
-     bytes (the 'compatible' variant) */
-
-#include <stdbool.h>
-
-#include <grpc/support/slice.h>
-
-/* URL percent encoding spec bitfield (usabel as 'unreserved_bytes' in
-   gpr_percent_encode_slice, gpr_strict_percent_decode_slice).
-   Flags [A-Za-z0-9-_.~] as unreserved bytes for the percent encoding routines
-   */
-extern const uint8_t gpr_url_percent_encoding_unreserved_bytes[256 / 8];
-/* URL percent encoding spec bitfield (usabel as 'unreserved_bytes' in
-   gpr_percent_encode_slice, gpr_strict_percent_decode_slice).
-   Flags ascii7 non-control characters excluding '%' as unreserved bytes for the
-   percent encoding routines */
-extern const uint8_t gpr_compatible_percent_encoding_unreserved_bytes[256 / 8];
-
-/* Percent-encode a slice, returning the new slice (this cannot fail):
-   unreserved_bytes is a bitfield indicating which bytes are considered
-   unreserved and thus do not need percent encoding */
-gpr_slice gpr_percent_encode_slice(gpr_slice slice,
-                                   const uint8_t *unreserved_bytes);
-/* Percent-decode a slice, strictly.
-   If the input is legal (contains no unreserved bytes, and legal % encodings),
-   returns true and sets *slice_out to the decoded slice.
-   If the input is not legal, returns false and leaves *slice_out untouched.
-   unreserved_bytes is a bitfield indicating which bytes are considered
-   unreserved and thus do not need percent encoding */
-bool gpr_strict_percent_decode_slice(gpr_slice slice_in,
-                                     const uint8_t *unreserved_bytes,
-                                     gpr_slice *slice_out);
-/* Percent-decode a slice, permissively.
-   If a % triplet can not be decoded, pass it through verbatim.
-   This cannot fail. */
-gpr_slice gpr_permissive_percent_decode_slice(gpr_slice slice_in);
-
-#endif /* GRPC_CORE_LIB_SUPPORT_PERCENT_ENCODING_H */
diff --git a/src/core/lib/support/slice.c b/src/core/lib/support/slice.c
deleted file mode 100644
index 8a2c0a9086..0000000000
--- a/src/core/lib/support/slice.c
+++ /dev/null
@@ -1,350 +0,0 @@
-/*
- *
- * Copyright 2015, Google Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/slice.h>
-
-#include <string.h>
-
-gpr_slice gpr_empty_slice(void) {
-  gpr_slice out;
-  out.refcount = 0;
-  out.data.inlined.length = 0;
-  return out;
-}
-
-gpr_slice gpr_slice_ref(gpr_slice slice) {
-  if (slice.refcount) {
-    slice.refcount->ref(slice.refcount);
-  }
-  return slice;
-}
-
-void gpr_slice_unref(gpr_slice slice) {
-  if (slice.refcount) {
-    slice.refcount->unref(slice.refcount);
-  }
-}
-
-/* gpr_slice_from_static_string support structure - a refcount that does
-   nothing */
-static void noop_ref_or_unref(void *unused) {}
-
-static gpr_slice_refcount noop_refcount = {noop_ref_or_unref,
-                                           noop_ref_or_unref};
-
-gpr_slice gpr_slice_from_static_string(const char *s) {
-  gpr_slice slice;
-  slice.refcount = &noop_refcount;
-  slice.data.refcounted.bytes = (uint8_t *)s;
-  slice.data.refcounted.length = strlen(s);
-  return slice;
-}
-
-/* gpr_slice_new support structures - we create a refcount object extended
-   with the user provided data pointer & destroy function */
-typedef struct new_slice_refcount {
-  gpr_slice_refcount rc;
-  gpr_refcount refs;
-  void (*user_destroy)(void *);
-  void *user_data;
-} new_slice_refcount;
-
-static void new_slice_ref(void *p) {
-  new_slice_refcount *r = p;
-  gpr_ref(&r->refs);
-}
-
-static void new_slice_unref(void *p) {
-  new_slice_refcount *r = p;
-  if (gpr_unref(&r->refs)) {
-    r->user_destroy(r->user_data);
-    gpr_free(r);
-  }
-}
-
-gpr_slice gpr_slice_new_with_user_data(void *p, size_t len,
-                                       void (*destroy)(void *),
-                                       void *user_data) {
-  gpr_slice slice;
-  new_slice_refcount *rc = gpr_malloc(sizeof(new_slice_refcount));
-  gpr_ref_init(&rc->refs, 1);
-  rc->rc.ref = new_slice_ref;
-  rc->rc.unref = new_slice_unref;
-  rc->user_destroy = destroy;
-  rc->user_data = user_data;
-
-  slice.refcount = &rc->rc;
-  slice.data.refcounted.bytes = p;
-  slice.data.refcounted.length = len;
-  return slice;
-}
-
-gpr_slice gpr_slice_new(void *p, size_t len, void (*destroy)(void *)) {
-  /* Pass "p" to *destroy when the slice is no longer needed. */
-  return gpr_slice_new_with_user_data(p, len, destroy, p);
-}
-
-/* gpr_slice_new_with_len support structures - we create a refcount object
-   extended with the user provided data pointer & destroy function */
-typedef struct new_with_len_slice_refcount {
-  gpr_slice_refcount rc;
-  gpr_refcount refs;
-  void *user_data;
-  size_t user_length;
-  void (*user_destroy)(void *, size_t);
-} new_with_len_slice_refcount;
-
-static void new_with_len_ref(void *p) {
-  new_with_len_slice_refcount *r = p;
-  gpr_ref(&r->refs);
-}
-
-static void new_with_len_unref(void *p) {
-  new_with_len_slice_refcount *r = p;
-  if (gpr_unref(&r->refs)) {
-    r->user_destroy(r->user_data, r->user_length);
-    gpr_free(r);
-  }
-}
-
-gpr_slice gpr_slice_new_with_len(void *p, size_t len,
-                                 void (*destroy)(void *, size_t)) {
-  gpr_slice slice;
-  new_with_len_slice_refcount *rc =
-      gpr_malloc(sizeof(new_with_len_slice_refcount));
-  gpr_ref_init(&rc->refs, 1);
-  rc->rc.ref = new_with_len_ref;
-  rc->rc.unref = new_with_len_unref;
-  rc->user_destroy = destroy;
-  rc->user_data = p;
-  rc->user_length = len;
-
-  slice.refcount = &rc->rc;
-  slice.data.refcounted.bytes = p;
-  slice.data.refcounted.length = len;
-  return slice;
-}
-
-gpr_slice gpr_slice_from_copied_buffer(const char *source, size_t length) {
-  gpr_slice slice = gpr_slice_malloc(length);
-  memcpy(GPR_SLICE_START_PTR(slice), source, length);
-  return slice;
-}
-
-gpr_slice gpr_slice_from_copied_string(const char *source) {
-  return gpr_slice_from_copied_buffer(source, strlen(source));
-}
-
-typedef struct {
-  gpr_slice_refcount base;
-  gpr_refcount refs;
-} malloc_refcount;
-
-static void malloc_ref(void *p) {
-  malloc_refcount *r = p;
-  gpr_ref(&r->refs);
-}
-
-static void malloc_unref(void *p) {
-  malloc_refcount *r = p;
-  if (gpr_unref(&r->refs)) {
-    gpr_free(r);
-  }
-}
-
-gpr_slice gpr_slice_malloc(size_t length) {
-  gpr_slice slice;
-
-  if (length > sizeof(slice.data.inlined.bytes)) {
-    /* Memory layout used by the slice created here:
-
-       +-----------+----------------------------------------------------------+
-       | refcount  | bytes                                                    |
-       +-----------+----------------------------------------------------------+
-
-       refcount is a malloc_refcount
-       bytes is an array of bytes of the requested length
-       Both parts are placed in the same allocation returned from gpr_malloc */
-    malloc_refcount *rc = gpr_malloc(sizeof(malloc_refcount) + length);
-
-    /* Initial refcount on rc is 1 - and it's up to the caller to release
-       this reference. */
-    gpr_ref_init(&rc->refs, 1);
-
-    rc->base.ref = malloc_ref;
-    rc->base.unref = malloc_unref;
-
-    /* Build up the slice to be returned. */
-    /* The slices refcount points back to the allocated block. */
-    slice.refcount = &rc->base;
-    /* The data bytes are placed immediately after the refcount struct */
-    slice.data.refcounted.bytes = (uint8_t *)(rc + 1);
-    /* And the length of the block is set to the requested length */
-    slice.data.refcounted.length = length;
-  } else {
-    /* small slice: just inline the data */
-    slice.refcount = NULL;
-    slice.data.inlined.length = (uint8_t)length;
-  }
-  return slice;
-}
-
-gpr_slice gpr_slice_sub_no_ref(gpr_slice source, size_t begin, size_t end) {
-  gpr_slice subset;
-
-  GPR_ASSERT(end >= begin);
-
-  if (source.refcount) {
-    /* Enforce preconditions */
-    GPR_ASSERT(source.data.refcounted.length >= end);
-
-    /* Build the result */
-    subset.refcount = source.refcount;
-    /* Point into the source array */
-    subset.data.refcounted.bytes = source.data.refcounted.bytes + begin;
-    subset.data.refcounted.length = end - begin;
-  } else {
-    /* Enforce preconditions */
-    GPR_ASSERT(source.data.inlined.length >= end);
-    subset.refcount = NULL;
-    subset.data.inlined.length = (uint8_t)(end - begin);
-    memcpy(subset.data.inlined.bytes, source.data.inlined.bytes + begin,
-           end - begin);
-  }
-  return subset;
-}
-
-gpr_slice gpr_slice_sub(gpr_slice source, size_t begin, size_t end) {
-  gpr_slice subset;
-
-  if (end - begin <= sizeof(subset.data.inlined.bytes)) {
-    subset.refcount = NULL;
-    subset.data.inlined.length = (uint8_t)(end - begin);
-    memcpy(subset.data.inlined.bytes, GPR_SLICE_START_PTR(source) + begin,
-           end - begin);
-  } else {
-    subset = gpr_slice_sub_no_ref(source, begin, end);
-    /* Bump the refcount */
-    subset.refcount->ref(subset.refcount);
-  }
-  return subset;
-}
-
-gpr_slice gpr_slice_split_tail(gpr_slice *source, size_t split) {
-  gpr_slice tail;
-
-  if (source->refcount == NULL) {
-    /* inlined data, copy it out */
-    GPR_ASSERT(source->data.inlined.length >= split);
-    tail.refcount = NULL;
-    tail.data.inlined.length = (uint8_t)(source->data.inlined.length - split);
-    memcpy(tail.data.inlined.bytes, source->data.inlined.bytes + split,
-           tail.data.inlined.length);
-    source->data.inlined.length = (uint8_t)split;
-  } else {
-    size_t tail_length = source->data.refcounted.length - split;
-    GPR_ASSERT(source->data.refcounted.length >= split);
-    if (tail_length < sizeof(tail.data.inlined.bytes)) {
-      /* Copy out the bytes - it'll be cheaper than refcounting */
-      tail.refcount = NULL;
-      tail.data.inlined.length = (uint8_t)tail_length;
-      memcpy(tail.data.inlined.bytes, source->data.refcounted.bytes + split,
-             tail_length);
-    } else {
-      /* Build the result */
-      tail.refcount = source->refcount;
-      /* Bump the refcount */
-      tail.refcount->ref(tail.refcount);
-      /* Point into the source array */
-      tail.data.refcounted.bytes = source->data.refcounted.bytes + split;
-      tail.data.refcounted.length = tail_length;
-    }
-    source->data.refcounted.length = split;
-  }
-
-  return tail;
-}
-
-gpr_slice gpr_slice_split_head(gpr_slice *source, size_t split) {
-  gpr_slice head;
-
-  if (source->refcount == NULL) {
-    GPR_ASSERT(source->data.inlined.length >= split);
-
-    head.refcount = NULL;
-    head.data.inlined.length = (uint8_t)split;
-    memcpy(head.data.inlined.bytes, source->data.inlined.bytes, split);
-    source->data.inlined.length =
-        (uint8_t)(source->data.inlined.length - split);
-    memmove(source->data.inlined.bytes, source->data.inlined.bytes + split,
-            source->data.inlined.length);
-  } else if (split < sizeof(head.data.inlined.bytes)) {
-    GPR_ASSERT(source->data.refcounted.length >= split);
-
-    head.refcount = NULL;
-    head.data.inlined.length = (uint8_t)split;
-    memcpy(head.data.inlined.bytes, source->data.refcounted.bytes, split);
-    source->data.refcounted.bytes += split;
-    source->data.refcounted.length -= split;
-  } else {
-    GPR_ASSERT(source->data.refcounted.length >= split);
-
-    /* Build the result */
-    head.refcount = source->refcount;
-    /* Bump the refcount */
-    head.refcount->ref(head.refcount);
-    /* Point into the source array */
-    head.data.refcounted.bytes = source->data.refcounted.bytes;
-    head.data.refcounted.length = split;
-    source->data.refcounted.bytes += split;
-    source->data.refcounted.length -= split;
-  }
-
-  return head;
-}
-
-int gpr_slice_cmp(gpr_slice a, gpr_slice b) {
-  int d = (int)(GPR_SLICE_LENGTH(a) - GPR_SLICE_LENGTH(b));
-  if (d != 0) return d;
-  return memcmp(GPR_SLICE_START_PTR(a), GPR_SLICE_START_PTR(b),
-                GPR_SLICE_LENGTH(a));
-}
-
-int gpr_slice_str_cmp(gpr_slice a, const char *b) {
-  size_t b_length = strlen(b);
-  int d = (int)(GPR_SLICE_LENGTH(a) - b_length);
-  if (d != 0) return d;
-  return memcmp(GPR_SLICE_START_PTR(a), b, b_length);
-}
diff --git a/src/core/lib/support/slice_buffer.c b/src/core/lib/support/slice_buffer.c
deleted file mode 100644
index 66f111d767..0000000000
--- a/src/core/lib/support/slice_buffer.c
+++ /dev/null
@@ -1,282 +0,0 @@
-/*
- *
- * Copyright 2015, Google Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#include <grpc/support/port_platform.h>
-#include <grpc/support/slice_buffer.h>
-
-#include <string.h>
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/useful.h>
-
-/* grow a buffer; requires GRPC_SLICE_BUFFER_INLINE_ELEMENTS > 1 */
-#define GROW(x) (3 * (x) / 2)
-
-static void maybe_embiggen(gpr_slice_buffer *sb) {
-  if (sb->count == sb->capacity) {
-    sb->capacity = GROW(sb->capacity);
-    GPR_ASSERT(sb->capacity > sb->count);
-    if (sb->slices == sb->inlined) {
-      sb->slices = gpr_malloc(sb->capacity * sizeof(gpr_slice));
-      memcpy(sb->slices, sb->inlined, sb->count * sizeof(gpr_slice));
-    } else {
-      sb->slices = gpr_realloc(sb->slices, sb->capacity * sizeof(gpr_slice));
-    }
-  }
-}
-
-void gpr_slice_buffer_init(gpr_slice_buffer *sb) {
-  sb->count = 0;
-  sb->length = 0;
-  sb->capacity = GRPC_SLICE_BUFFER_INLINE_ELEMENTS;
-  sb->slices = sb->inlined;
-}
-
-void gpr_slice_buffer_destroy(gpr_slice_buffer *sb) {
-  gpr_slice_buffer_reset_and_unref(sb);
-  if (sb->slices != sb->inlined) {
-    gpr_free(sb->slices);
-  }
-}
-
-uint8_t *gpr_slice_buffer_tiny_add(gpr_slice_buffer *sb, size_t n) {
-  gpr_slice *back;
-  uint8_t *out;
-
-  sb->length += n;
-
-  if (sb->count == 0) goto add_new;
-  back = &sb->slices[sb->count - 1];
-  if (back->refcount) goto add_new;
-  if ((back->data.inlined.length + n) > sizeof(back->data.inlined.bytes))
-    goto add_new;
-  out = back->data.inlined.bytes + back->data.inlined.length;
-  back->data.inlined.length = (uint8_t)(back->data.inlined.length + n);
-  return out;
-
-add_new:
-  maybe_embiggen(sb);
-  back = &sb->slices[sb->count];
-  sb->count++;
-  back->refcount = NULL;
-  back->data.inlined.length = (uint8_t)n;
-  return back->data.inlined.bytes;
-}
-
-size_t gpr_slice_buffer_add_indexed(gpr_slice_buffer *sb, gpr_slice s) {
-  size_t out = sb->count;
-  maybe_embiggen(sb);
-  sb->slices[out] = s;
-  sb->length += GPR_SLICE_LENGTH(s);
-  sb->count = out + 1;
-  return out;
-}
-
-void gpr_slice_buffer_add(gpr_slice_buffer *sb, gpr_slice s) {
-  size_t n = sb->count;
-  /* if both the last slice in the slice buffer and the slice being added
-     are inlined (that is, that they carry their data inside the slice data
-     structure), and the back slice is not full, then concatenate directly
-     into the back slice, preventing many small slices being passed into
-     writes */
-  if (!s.refcount && n) {
-    gpr_slice *back = &sb->slices[n - 1];
-    if (!back->refcount && back->data.inlined.length < GPR_SLICE_INLINED_SIZE) {
-      if (s.data.inlined.length + back->data.inlined.length <=
-          GPR_SLICE_INLINED_SIZE) {
-        memcpy(back->data.inlined.bytes + back->data.inlined.length,
-               s.data.inlined.bytes, s.data.inlined.length);
-        back->data.inlined.length =
-            (uint8_t)(back->data.inlined.length + s.data.inlined.length);
-      } else {
-        size_t cp1 = GPR_SLICE_INLINED_SIZE - back->data.inlined.length;
-        memcpy(back->data.inlined.bytes + back->data.inlined.length,
-               s.data.inlined.bytes, cp1);
-        back->data.inlined.length = GPR_SLICE_INLINED_SIZE;
-        maybe_embiggen(sb);
-        back = &sb->slices[n];
-        sb->count = n + 1;
-        back->refcount = NULL;
-        back->data.inlined.length = (uint8_t)(s.data.inlined.length - cp1);
-        memcpy(back->data.inlined.bytes, s.data.inlined.bytes + cp1,
-               s.data.inlined.length - cp1);
-      }
-      sb->length += s.data.inlined.length;
-      return; /* early out */
-    }
-  }
-  gpr_slice_buffer_add_indexed(sb, s);
-}
-
-void gpr_slice_buffer_addn(gpr_slice_buffer *sb, gpr_slice *s, size_t n) {
-  size_t i;
-  for (i = 0; i < n; i++) {
-    gpr_slice_buffer_add(sb, s[i]);
-  }
-}
-
-void gpr_slice_buffer_pop(gpr_slice_buffer *sb) {
-  if (sb->count != 0) {
-    size_t count = --sb->count;
-    sb->length -= GPR_SLICE_LENGTH(sb->slices[count]);
-  }
-}
-
-void gpr_slice_buffer_reset_and_unref(gpr_slice_buffer *sb) {
-  size_t i;
-
-  for (i = 0; i < sb->count; i++) {
-    gpr_slice_unref(sb->slices[i]);
-  }
-
-  sb->count = 0;
-  sb->length = 0;
-}
-
-void gpr_slice_buffer_swap(gpr_slice_buffer *a, gpr_slice_buffer *b) {
-  GPR_SWAP(size_t, a->count, b->count);
-  GPR_SWAP(size_t, a->capacity, b->capacity);
-  GPR_SWAP(size_t, a->length, b->length);
-
-  if (a->slices == a->inlined) {
-    if (b->slices == b->inlined) {
-      /* swap contents of inlined buffer */
-      gpr_slice temp[GRPC_SLICE_BUFFER_INLINE_ELEMENTS];
-      memcpy(temp, a->slices, b->count * sizeof(gpr_slice));
-      memcpy(a->slices, b->slices, a->count * sizeof(gpr_slice));
-      memcpy(b->slices, temp, b->count * sizeof(gpr_slice));
-    } else {
-      /* a is inlined, b is not - copy a inlined into b, fix pointers */
-      a->slices = b->slices;
-      b->slices = b->inlined;
-      memcpy(b->slices, a->inlined, b->count * sizeof(gpr_slice));
-    }
-  } else if (b->slices == b->inlined) {
-    /* b is inlined, a is not - copy b inlined int a, fix pointers */
-    b->slices = a->slices;
-    a->slices = a->inlined;
-    memcpy(a->slices, b->inlined, a->count * sizeof(gpr_slice));
-  } else {
-    /* no inlining: easy swap */
-    GPR_SWAP(gpr_slice *, a->slices, b->slices);
-  }
-}
-
-void gpr_slice_buffer_move_into(gpr_slice_buffer *src, gpr_slice_buffer *dst) {
-  /* anything to move? */
-  if (src->count == 0) {
-    return;
-  }
-  /* anything in dst? */
-  if (dst->count == 0) {
-    gpr_slice_buffer_swap(src, dst);
-    return;
-  }
-  /* both buffers have data - copy, and reset src */
-  gpr_slice_buffer_addn(dst, src->slices, src->count);
-  src->count = 0;
-  src->length = 0;
-}
-
-void gpr_slice_buffer_move_first(gpr_slice_buffer *src, size_t n,
-                                 gpr_slice_buffer *dst) {
-  size_t src_idx;
-  size_t output_len = dst->length + n;
-  size_t new_input_len = src->length - n;
-  GPR_ASSERT(src->length >= n);
-  if (src->length == n) {
-    gpr_slice_buffer_move_into(src, dst);
-    return;
-  }
-  src_idx = 0;
-  while (src_idx < src->capacity) {
-    gpr_slice slice = src->slices[src_idx];
-    size_t slice_len = GPR_SLICE_LENGTH(slice);
-    if (n > slice_len) {
-      gpr_slice_buffer_add(dst, slice);
-      n -= slice_len;
-      src_idx++;
-    } else if (n == slice_len) {
-      gpr_slice_buffer_add(dst, slice);
-      src_idx++;
-      break;
-    } else { /* n < slice_len */
-      src->slices[src_idx] = gpr_slice_split_tail(&slice, n);
-      GPR_ASSERT(GPR_SLICE_LENGTH(slice) == n);
-      GPR_ASSERT(GPR_SLICE_LENGTH(src->slices[src_idx]) == slice_len - n);
-      gpr_slice_buffer_add(dst, slice);
-      break;
-    }
-  }
-  GPR_ASSERT(dst->length == output_len);
-  memmove(src->slices, src->slices + src_idx,
-          sizeof(gpr_slice) * (src->count - src_idx));
-  src->count -= src_idx;
-  src->length = new_input_len;
-  GPR_ASSERT(src->count > 0);
-}
-
-void gpr_slice_buffer_trim_end(gpr_slice_buffer *sb, size_t n,
-                               gpr_slice_buffer *garbage) {
-  GPR_ASSERT(n <= sb->length);
-  sb->length -= n;
-  for (;;) {
-    size_t idx = sb->count - 1;
-    gpr_slice slice = sb->slices[idx];
-    size_t slice_len = GPR_SLICE_LENGTH(slice);
-    if (slice_len > n) {
-      sb->slices[idx] = gpr_slice_split_head(&slice, slice_len - n);
-      gpr_slice_buffer_add_indexed(garbage, slice);
-      return;
-    } else if (slice_len == n) {
-      gpr_slice_buffer_add_indexed(garbage, slice);
-      sb->count = idx;
-      return;
-    } else {
-      gpr_slice_buffer_add_indexed(garbage, slice);
-      n -= slice_len;
-      sb->count = idx;
-    }
-  }
-}
-
-gpr_slice gpr_slice_buffer_take_first(gpr_slice_buffer *sb) {
-  gpr_slice slice;
-  GPR_ASSERT(sb->count > 0);
-  slice = sb->slices[0];
-  memmove(&sb->slices[0], &sb->slices[1], (sb->count - 1) * sizeof(gpr_slice));
-  sb->count--;
-  sb->length -= GPR_SLICE_LENGTH(slice);
-  return slice;
-}
diff --git a/src/core/lib/support/string.c b/src/core/lib/support/string.c
index d17fb9da4b..f10a30f0fd 100644
--- a/src/core/lib/support/string.c
+++ b/src/core/lib/support/string.c
@@ -34,7 +34,9 @@
 #include "src/core/lib/support/string.h"
 
 #include <ctype.h>
+#include <limits.h>
 #include <stddef.h>
+#include <stdlib.h>
 #include <string.h>
 
 #include <grpc/support/alloc.h>
@@ -120,11 +122,6 @@ char *gpr_dump(const char *buf, size_t len, uint32_t flags) {
   return out.data;
 }
 
-char *gpr_dump_slice(gpr_slice s, uint32_t flags) {
-  return gpr_dump((const char *)GPR_SLICE_START_PTR(s), GPR_SLICE_LENGTH(s),
-                  flags);
-}
-
 int gpr_parse_bytes_to_uint32(const char *buf, size_t len, uint32_t *result) {
   uint32_t out = 0;
   uint32_t new;
@@ -194,6 +191,13 @@ int int64_ttoa(int64_t value, char *string) {
   return i;
 }
 
+int gpr_parse_nonnegative_int(const char *value) {
+  char *end;
+  long result = strtol(value, &end, 0);
+  if (*end != '\0' || result < 0 || result > INT_MAX) return -1;
+  return (int)result;
+}
+
 char *gpr_leftpad(const char *str, char flag, size_t length) {
   const size_t str_length = strlen(str);
   const size_t out_length = str_length > length ? str_length : length;
@@ -239,50 +243,6 @@ char *gpr_strjoin_sep(const char **strs, size_t nstrs, const char *sep,
   return out;
 }
 
-/** Finds the initial (\a begin) and final (\a end) offsets of the next
- * substring from \a str + \a read_offset until the next \a sep or the end of \a
- * str.
- *
- * Returns 1 and updates \a begin and \a end. Returns 0 otherwise. */
-static int slice_find_separator_offset(const gpr_slice str, const char *sep,
-                                       const size_t read_offset, size_t *begin,
-                                       size_t *end) {
-  size_t i;
-  const uint8_t *str_ptr = GPR_SLICE_START_PTR(str) + read_offset;
-  const size_t str_len = GPR_SLICE_LENGTH(str) - read_offset;
-  const size_t sep_len = strlen(sep);
-  if (str_len < sep_len) {
-    return 0;
-  }
-
-  for (i = 0; i <= str_len - sep_len; i++) {
-    if (memcmp(str_ptr + i, sep, sep_len) == 0) {
-      *begin = read_offset;
-      *end = read_offset + i;
-      return 1;
-    }
-  }
-  return 0;
-}
-
-void gpr_slice_split(gpr_slice str, const char *sep, gpr_slice_buffer *dst) {
-  const size_t sep_len = strlen(sep);
-  size_t begin, end;
-
-  GPR_ASSERT(sep_len > 0);
-
-  if (slice_find_separator_offset(str, sep, 0, &begin, &end) != 0) {
-    do {
-      gpr_slice_buffer_add_indexed(dst, gpr_slice_sub(str, begin, end));
-    } while (slice_find_separator_offset(str, sep, end + sep_len, &begin,
-                                         &end) != 0);
-    gpr_slice_buffer_add_indexed(
-        dst, gpr_slice_sub(str, end + sep_len, GPR_SLICE_LENGTH(str)));
-  } else { /* no sep found, add whole input */
-    gpr_slice_buffer_add_indexed(dst, gpr_slice_ref(str));
-  }
-}
-
 void gpr_strvec_init(gpr_strvec *sv) { memset(sv, 0, sizeof(*sv)); }
 
 void gpr_strvec_destroy(gpr_strvec *sv) {
diff --git a/src/core/lib/support/string.h b/src/core/lib/support/string.h
index 9a94e9471c..e933e2eb46 100644
--- a/src/core/lib/support/string.h
+++ b/src/core/lib/support/string.h
@@ -36,9 +36,9 @@
 
 #include <stddef.h>
 
+#include <grpc/slice.h>
+#include <grpc/slice_buffer.h>
 #include <grpc/support/port_platform.h>
-#include <grpc/support/slice.h>
-#include <grpc/support/slice_buffer.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -54,9 +54,6 @@ extern "C" {
    Result should be freed with gpr_free() */
 char *gpr_dump(const char *buf, size_t len, uint32_t flags);
 
-/* Calls gpr_dump on a slice. */
-char *gpr_dump_slice(gpr_slice slice, uint32_t flags);
-
 /* Parses an array of bytes into an integer (base 10). Returns 1 on success,
    0 on failure. */
 int gpr_parse_bytes_to_uint32(const char *data, size_t length,
@@ -80,6 +77,9 @@ NOTE: This function ensures sufficient bit width even on Win x64,
 where long is 32bit is size.*/
 int int64_ttoa(int64_t value, char *output);
 
+// Parses a non-negative number from a value string.  Returns -1 on error.
+int gpr_parse_nonnegative_int(const char *value);
+
 /* Reverse a run of bytes */
 void gpr_reverse_bytes(char *str, int len);
 
@@ -98,10 +98,6 @@ char *gpr_strjoin(const char **strs, size_t nstrs, size_t *total_length);
 char *gpr_strjoin_sep(const char **strs, size_t nstrs, const char *sep,
                       size_t *total_length);
 
-/** Split \a str by the separator \a sep. Results are stored in \a dst, which
- * should be a properly initialized instance. */
-void gpr_slice_split(gpr_slice str, const char *sep, gpr_slice_buffer *dst);
-
 /* A vector of strings... for building up a final string one piece at a time */
 typedef struct {
   char **strs;
diff --git a/src/core/lib/support/subprocess_posix.c b/src/core/lib/support/subprocess_posix.c
index 4f4de9298e..4247a1c12b 100644
--- a/src/core/lib/support/subprocess_posix.c
+++ b/src/core/lib/support/subprocess_posix.c
@@ -40,6 +40,7 @@
 #include <assert.h>
 #include <errno.h>
 #include <signal.h>
+#include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -52,7 +53,7 @@
 
 struct gpr_subprocess {
   int pid;
-  int joined;
+  bool joined;
 };
 
 const char *gpr_subprocess_binary_extension() { return ""; }
@@ -97,9 +98,11 @@ retry:
     if (errno == EINTR) {
       goto retry;
     }
-    gpr_log(GPR_ERROR, "waitpid failed: %s", strerror(errno));
+    gpr_log(GPR_ERROR, "waitpid failed for pid %d: %s", p->pid,
+            strerror(errno));
     return -1;
   }
+  p->joined = true;
   return status;
 }
 
diff --git a/src/core/lib/support/tmpfile.h b/src/core/lib/support/tmpfile.h
index 059142ab0f..8952e5ec3d 100644
--- a/src/core/lib/support/tmpfile.h
+++ b/src/core/lib/support/tmpfile.h
@@ -36,7 +36,7 @@
 
 #include <stdio.h>
 
-#include <grpc/support/slice.h>
+#include <grpc/slice.h>
 
 #ifdef __cplusplus
 extern "C" {