grpc 1.7.3 → 1.8.0

data/src/core/lib/slice/{percent_encoding.c → percent_encoding.cc}

@@ -32,19 +32,19 @@ const uint8_t grpc_compatible_percent_encoding_unreserved_bytes[256 / 8] = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
 static bool is_unreserved_character(uint8_t c,
-                                    const uint8_t *unreserved_bytes) {
+                                    const uint8_t* unreserved_bytes) {
   return ((unreserved_bytes[c / 8] >> (c % 8)) & 1) != 0;
 }
 
 grpc_slice grpc_percent_encode_slice(grpc_slice slice,
-                                     const uint8_t *unreserved_bytes) {
+                                     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 = GRPC_SLICE_START_PTR(slice);
-  const uint8_t *slice_end = GRPC_SLICE_END_PTR(slice);
-  const uint8_t *p;
+  const uint8_t* slice_start = GRPC_SLICE_START_PTR(slice);
+  const uint8_t* slice_end = GRPC_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);
@@ -57,7 +57,7 @@ grpc_slice grpc_percent_encode_slice(grpc_slice slice,
   }
   // second pass: actually encode
   grpc_slice out = GRPC_SLICE_MALLOC(output_length);
-  uint8_t *q = GRPC_SLICE_START_PTR(out);
+  uint8_t* q = GRPC_SLICE_START_PTR(out);
   for (p = slice_start; p < slice_end; p++) {
     if (is_unreserved_character(*p, unreserved_bytes)) {
       *q++ = *p;
@@ -71,7 +71,7 @@ grpc_slice grpc_percent_encode_slice(grpc_slice slice,
   return out;
 }
 
-static bool valid_hex(const uint8_t *p, const uint8_t *end) {
+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');
@@ -85,10 +85,10 @@ static uint8_t dehex(uint8_t c) {
 }
 
 bool grpc_strict_percent_decode_slice(grpc_slice slice_in,
-                                      const uint8_t *unreserved_bytes,
-                                      grpc_slice *slice_out) {
-  const uint8_t *p = GRPC_SLICE_START_PTR(slice_in);
-  const uint8_t *in_end = GRPC_SLICE_END_PTR(slice_in);
+                                      const uint8_t* unreserved_bytes,
+                                      grpc_slice* slice_out) {
+  const uint8_t* p = GRPC_SLICE_START_PTR(slice_in);
+  const uint8_t* in_end = GRPC_SLICE_END_PTR(slice_in);
   size_t out_length = 0;
   bool any_percent_encoded_stuff = false;
   while (p != in_end) {
@@ -111,7 +111,7 @@ bool grpc_strict_percent_decode_slice(grpc_slice slice_in,
   }
   p = GRPC_SLICE_START_PTR(slice_in);
   *slice_out = GRPC_SLICE_MALLOC(out_length);
-  uint8_t *q = GRPC_SLICE_START_PTR(*slice_out);
+  uint8_t* q = GRPC_SLICE_START_PTR(*slice_out);
   while (p != in_end) {
     if (*p == '%') {
       *q++ = (uint8_t)(dehex(p[1]) << 4) | (dehex(p[2]));
@@ -125,8 +125,8 @@ bool grpc_strict_percent_decode_slice(grpc_slice slice_in,
 }
 
 grpc_slice grpc_permissive_percent_decode_slice(grpc_slice slice_in) {
-  const uint8_t *p = GRPC_SLICE_START_PTR(slice_in);
-  const uint8_t *in_end = GRPC_SLICE_END_PTR(slice_in);
+  const uint8_t* p = GRPC_SLICE_START_PTR(slice_in);
+  const uint8_t* in_end = GRPC_SLICE_END_PTR(slice_in);
   size_t out_length = 0;
   bool any_percent_encoded_stuff = false;
   while (p != in_end) {
@@ -149,7 +149,7 @@ grpc_slice grpc_permissive_percent_decode_slice(grpc_slice slice_in) {
   }
   p = GRPC_SLICE_START_PTR(slice_in);
   grpc_slice out = GRPC_SLICE_MALLOC(out_length);
-  uint8_t *q = GRPC_SLICE_START_PTR(out);
+  uint8_t* q = GRPC_SLICE_START_PTR(out);
   while (p != in_end) {
     if (*p == '%') {
       if (!valid_hex(p + 1, in_end) || !valid_hex(p + 2, in_end)) {

data/src/core/lib/slice/percent_encoding.h

@@ -30,6 +30,10 @@
 
 #include <grpc/slice.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* URL percent encoding spec bitfield (usabel as 'unreserved_bytes' in
    grpc_percent_encode_slice, grpc_strict_percent_decode_slice).
    Flags [A-Za-z0-9-_.~] as unreserved bytes for the percent encoding routines
@@ -45,7 +49,7 @@ extern const uint8_t grpc_compatible_percent_encoding_unreserved_bytes[256 / 8];
    unreserved_bytes is a bitfield indicating which bytes are considered
    unreserved and thus do not need percent encoding */
 grpc_slice grpc_percent_encode_slice(grpc_slice slice,
-                                     const uint8_t *unreserved_bytes);
+                                     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.
@@ -53,11 +57,15 @@ grpc_slice grpc_percent_encode_slice(grpc_slice slice,
    unreserved_bytes is a bitfield indicating which bytes are considered
    unreserved and thus do not need percent encoding */
 bool grpc_strict_percent_decode_slice(grpc_slice slice_in,
-                                      const uint8_t *unreserved_bytes,
-                                      grpc_slice *slice_out);
+                                      const uint8_t* unreserved_bytes,
+                                      grpc_slice* slice_out);
 /* Percent-decode a slice, permissively.
    If a % triplet can not be decoded, pass it through verbatim.
    This cannot fail. */
 grpc_slice grpc_permissive_percent_decode_slice(grpc_slice slice_in);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_SLICE_PERCENT_ENCODING_H */

data/src/core/lib/slice/{slice.c → slice.cc}

@@ -26,8 +26,8 @@
 
 #include "src/core/lib/iomgr/exec_ctx.h"
 
-char *grpc_slice_to_c_string(grpc_slice slice) {
-  char *out = (char *)gpr_malloc(GRPC_SLICE_LENGTH(slice) + 1);
+char* grpc_slice_to_c_string(grpc_slice slice) {
+  char* out = (char*)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;
@@ -35,7 +35,7 @@ char *grpc_slice_to_c_string(grpc_slice slice) {
 
 grpc_slice grpc_empty_slice(void) {
   grpc_slice out;
-  out.refcount = NULL;
+  out.refcount = nullptr;
   out.data.inlined.length = 0;
   return out;
 }
@@ -54,7 +54,7 @@ grpc_slice grpc_slice_ref_internal(grpc_slice slice) {
   return slice;
 }
 
-void grpc_slice_unref_internal(grpc_exec_ctx *exec_ctx, grpc_slice slice) {
+void grpc_slice_unref_internal(grpc_exec_ctx* exec_ctx, grpc_slice slice) {
   if (slice.refcount) {
     slice.refcount->vtable->unref(exec_ctx, slice.refcount);
   }
@@ -74,8 +74,8 @@ void grpc_slice_unref(grpc_slice slice) {
 
 /* grpc_slice_from_static_string support structure - a refcount that does
    nothing */
-static void noop_ref(void *unused) {}
-static void noop_unref(grpc_exec_ctx *exec_ctx, void *unused) {}
+static void noop_ref(void* unused) {}
+static void noop_unref(grpc_exec_ctx* exec_ctx, void* unused) {}
 
 static const grpc_slice_refcount_vtable noop_refcount_vtable = {
     noop_ref, noop_unref, grpc_slice_default_eq_impl,
@@ -83,15 +83,15 @@ static const grpc_slice_refcount_vtable noop_refcount_vtable = {
 static grpc_slice_refcount noop_refcount = {&noop_refcount_vtable,
                                             &noop_refcount};
 
-grpc_slice grpc_slice_from_static_buffer(const void *s, size_t len) {
+grpc_slice grpc_slice_from_static_buffer(const void* s, size_t len) {
   grpc_slice slice;
   slice.refcount = &noop_refcount;
-  slice.data.refcounted.bytes = (uint8_t *)s;
+  slice.data.refcounted.bytes = (uint8_t*)s;
   slice.data.refcounted.length = len;
   return slice;
 }
 
-grpc_slice grpc_slice_from_static_string(const char *s) {
+grpc_slice grpc_slice_from_static_string(const char* s) {
   return grpc_slice_from_static_buffer(s, strlen(s));
 }
 
@@ -100,17 +100,17 @@ grpc_slice grpc_slice_from_static_string(const char *s) {
 typedef struct new_slice_refcount {
   grpc_slice_refcount rc;
   gpr_refcount refs;
-  void (*user_destroy)(void *);
-  void *user_data;
+  void (*user_destroy)(void*);
+  void* user_data;
 } new_slice_refcount;
 
-static void new_slice_ref(void *p) {
-  new_slice_refcount *r = (new_slice_refcount *)p;
+static void new_slice_ref(void* p) {
+  new_slice_refcount* r = (new_slice_refcount*)p;
   gpr_ref(&r->refs);
 }
 
-static void new_slice_unref(grpc_exec_ctx *exec_ctx, void *p) {
-  new_slice_refcount *r = (new_slice_refcount *)p;
+static void new_slice_unref(grpc_exec_ctx* exec_ctx, void* p) {
+  new_slice_refcount* r = (new_slice_refcount*)p;
   if (gpr_unref(&r->refs)) {
     r->user_destroy(r->user_data);
     gpr_free(r);
@@ -121,12 +121,12 @@ static const grpc_slice_refcount_vtable new_slice_vtable = {
     new_slice_ref, new_slice_unref, grpc_slice_default_eq_impl,
     grpc_slice_default_hash_impl};
 
-grpc_slice grpc_slice_new_with_user_data(void *p, size_t len,
-                                         void (*destroy)(void *),
-                                         void *user_data) {
+grpc_slice grpc_slice_new_with_user_data(void* p, size_t len,
+                                         void (*destroy)(void*),
+                                         void* user_data) {
   grpc_slice slice;
-  new_slice_refcount *rc =
-      (new_slice_refcount *)gpr_malloc(sizeof(new_slice_refcount));
+  new_slice_refcount* rc =
+      (new_slice_refcount*)gpr_malloc(sizeof(new_slice_refcount));
   gpr_ref_init(&rc->refs, 1);
   rc->rc.vtable = &new_slice_vtable;
   rc->rc.sub_refcount = &rc->rc;
@@ -134,12 +134,12 @@ grpc_slice grpc_slice_new_with_user_data(void *p, size_t len,
   rc->user_data = user_data;
 
   slice.refcount = &rc->rc;
-  slice.data.refcounted.bytes = (uint8_t *)p;
+  slice.data.refcounted.bytes = (uint8_t*)p;
   slice.data.refcounted.length = len;
   return slice;
 }
 
-grpc_slice grpc_slice_new(void *p, size_t len, void (*destroy)(void *)) {
+grpc_slice grpc_slice_new(void* p, size_t len, void (*destroy)(void*)) {
   /* Pass "p" to *destroy when the slice is no longer needed. */
   return grpc_slice_new_with_user_data(p, len, destroy, p);
 }
@@ -149,18 +149,18 @@ grpc_slice grpc_slice_new(void *p, size_t len, void (*destroy)(void *)) {
 typedef struct new_with_len_slice_refcount {
   grpc_slice_refcount rc;
   gpr_refcount refs;
-  void *user_data;
+  void* user_data;
   size_t user_length;
-  void (*user_destroy)(void *, size_t);
+  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 = (new_with_len_slice_refcount *)p;
+static void new_with_len_ref(void* p) {
+  new_with_len_slice_refcount* r = (new_with_len_slice_refcount*)p;
   gpr_ref(&r->refs);
 }
 
-static void new_with_len_unref(grpc_exec_ctx *exec_ctx, void *p) {
-  new_with_len_slice_refcount *r = (new_with_len_slice_refcount *)p;
+static void new_with_len_unref(grpc_exec_ctx* exec_ctx, void* p) {
+  new_with_len_slice_refcount* r = (new_with_len_slice_refcount*)p;
   if (gpr_unref(&r->refs)) {
     r->user_destroy(r->user_data, r->user_length);
     gpr_free(r);
@@ -171,10 +171,10 @@ static const grpc_slice_refcount_vtable new_with_len_vtable = {
     new_with_len_ref, new_with_len_unref, grpc_slice_default_eq_impl,
     grpc_slice_default_hash_impl};
 
-grpc_slice grpc_slice_new_with_len(void *p, size_t len,
-                                   void (*destroy)(void *, size_t)) {
+grpc_slice grpc_slice_new_with_len(void* p, size_t len,
+                                   void (*destroy)(void*, size_t)) {
   grpc_slice slice;
-  new_with_len_slice_refcount *rc = (new_with_len_slice_refcount *)gpr_malloc(
+  new_with_len_slice_refcount* rc = (new_with_len_slice_refcount*)gpr_malloc(
       sizeof(new_with_len_slice_refcount));
   gpr_ref_init(&rc->refs, 1);
   rc->rc.vtable = &new_with_len_vtable;
@@ -184,19 +184,19 @@ grpc_slice grpc_slice_new_with_len(void *p, size_t len,
   rc->user_length = len;
 
   slice.refcount = &rc->rc;
-  slice.data.refcounted.bytes = (uint8_t *)p;
+  slice.data.refcounted.bytes = (uint8_t*)p;
   slice.data.refcounted.length = len;
   return slice;
 }
 
-grpc_slice grpc_slice_from_copied_buffer(const char *source, size_t length) {
+grpc_slice grpc_slice_from_copied_buffer(const char* source, size_t length) {
   if (length == 0) return grpc_empty_slice();
   grpc_slice slice = GRPC_SLICE_MALLOC(length);
   memcpy(GRPC_SLICE_START_PTR(slice), source, length);
   return slice;
 }
 
-grpc_slice grpc_slice_from_copied_string(const char *source) {
+grpc_slice grpc_slice_from_copied_string(const char* source) {
   return grpc_slice_from_copied_buffer(source, strlen(source));
 }
 
@@ -205,13 +205,13 @@ typedef struct {
   gpr_refcount refs;
 } malloc_refcount;
 
-static void malloc_ref(void *p) {
-  malloc_refcount *r = (malloc_refcount *)p;
+static void malloc_ref(void* p) {
+  malloc_refcount* r = (malloc_refcount*)p;
   gpr_ref(&r->refs);
 }
 
-static void malloc_unref(grpc_exec_ctx *exec_ctx, void *p) {
-  malloc_refcount *r = (malloc_refcount *)p;
+static void malloc_unref(grpc_exec_ctx* exec_ctx, void* p) {
+  malloc_refcount* r = (malloc_refcount*)p;
   if (gpr_unref(&r->refs)) {
     gpr_free(r);
   }
@@ -233,8 +233,8 @@ grpc_slice grpc_slice_malloc_large(size_t length) {
      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 =
-      (malloc_refcount *)gpr_malloc(sizeof(malloc_refcount) + length);
+  malloc_refcount* rc =
+      (malloc_refcount*)gpr_malloc(sizeof(malloc_refcount) + length);
 
   /* Initial refcount on rc is 1 - and it's up to the caller to release
      this reference. */
@@ -247,7 +247,7 @@ grpc_slice grpc_slice_malloc_large(size_t length) {
   /* 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);
+  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;
   return slice;
@@ -260,7 +260,7 @@ grpc_slice grpc_slice_malloc(size_t length) {
     return grpc_slice_malloc_large(length);
   } else {
     /* small slice: just inline the data */
-    slice.refcount = NULL;
+    slice.refcount = nullptr;
     slice.data.inlined.length = (uint8_t)length;
   }
   return slice;
@@ -283,7 +283,7 @@ grpc_slice grpc_slice_sub_no_ref(grpc_slice source, size_t begin, size_t end) {
   } else {
     /* Enforce preconditions */
     GPR_ASSERT(source.data.inlined.length >= end);
-    subset.refcount = NULL;
+    subset.refcount = nullptr;
     subset.data.inlined.length = (uint8_t)(end - begin);
     memcpy(subset.data.inlined.bytes, source.data.inlined.bytes + begin,
            end - begin);
@@ -295,7 +295,7 @@ grpc_slice grpc_slice_sub(grpc_slice source, size_t begin, size_t end) {
   grpc_slice subset;
 
   if (end - begin <= sizeof(subset.data.inlined.bytes)) {
-    subset.refcount = NULL;
+    subset.refcount = nullptr;
     subset.data.inlined.length = (uint8_t)(end - begin);
     memcpy(subset.data.inlined.bytes, GRPC_SLICE_START_PTR(source) + begin,
            end - begin);
@@ -307,14 +307,14 @@ grpc_slice grpc_slice_sub(grpc_slice source, size_t begin, size_t end) {
   return subset;
 }
 
-grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice *source, size_t split,
+grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* source, size_t split,
                                            grpc_slice_ref_whom ref_whom) {
   grpc_slice tail;
 
-  if (source->refcount == NULL) {
+  if (source->refcount == nullptr) {
     /* inlined data, copy it out */
     GPR_ASSERT(source->data.inlined.length >= split);
-    tail.refcount = NULL;
+    tail.refcount = nullptr;
     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);
@@ -325,7 +325,7 @@ grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice *source, size_t split,
     if (tail_length < sizeof(tail.data.inlined.bytes) &&
         ref_whom != GRPC_SLICE_REF_TAIL) {
       /* Copy out the bytes - it'll be cheaper than refcounting */
-      tail.refcount = NULL;
+      tail.refcount = nullptr;
       tail.data.inlined.length = (uint8_t)tail_length;
       memcpy(tail.data.inlined.bytes, source->data.refcounted.bytes + split,
              tail_length);
@@ -358,17 +358,17 @@ grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice *source, size_t split,
   return tail;
 }
 
-grpc_slice grpc_slice_split_tail(grpc_slice *source, size_t split) {
+grpc_slice grpc_slice_split_tail(grpc_slice* source, size_t split) {
   return grpc_slice_split_tail_maybe_ref(source, split, GRPC_SLICE_REF_BOTH);
 }
 
-grpc_slice grpc_slice_split_head(grpc_slice *source, size_t split) {
+grpc_slice grpc_slice_split_head(grpc_slice* source, size_t split) {
   grpc_slice head;
 
-  if (source->refcount == NULL) {
+  if (source->refcount == nullptr) {
     GPR_ASSERT(source->data.inlined.length >= split);
 
-    head.refcount = NULL;
+    head.refcount = nullptr;
     head.data.inlined.length = (uint8_t)split;
     memcpy(head.data.inlined.bytes, source->data.inlined.bytes, split);
     source->data.inlined.length =
@@ -378,7 +378,7 @@ grpc_slice grpc_slice_split_head(grpc_slice *source, size_t split) {
   } else if (split < sizeof(head.data.inlined.bytes)) {
     GPR_ASSERT(source->data.refcounted.length >= split);
 
-    head.refcount = NULL;
+    head.refcount = nullptr;
     head.data.inlined.length = (uint8_t)split;
     memcpy(head.data.inlined.bytes, source->data.refcounted.bytes, split);
     source->refcount = source->refcount->sub_refcount;
@@ -423,7 +423,7 @@ int grpc_slice_cmp(grpc_slice a, grpc_slice b) {
                 GRPC_SLICE_LENGTH(a));
 }
 
-int grpc_slice_str_cmp(grpc_slice a, const char *b) {
+int grpc_slice_str_cmp(grpc_slice a, const char* b) {
   size_t b_length = strlen(b);
   int d = (int)(GRPC_SLICE_LENGTH(a) - b_length);
   if (d != 0) return d;
@@ -431,20 +431,20 @@ int grpc_slice_str_cmp(grpc_slice a, const char *b) {
 }
 
 int grpc_slice_is_equivalent(grpc_slice a, grpc_slice b) {
-  if (a.refcount == NULL || b.refcount == NULL) {
+  if (a.refcount == nullptr || b.refcount == nullptr) {
     return grpc_slice_eq(a, b);
   }
   return a.data.refcounted.length == b.data.refcounted.length &&
          a.data.refcounted.bytes == b.data.refcounted.bytes;
 }
 
-int grpc_slice_buf_start_eq(grpc_slice a, const void *b, size_t len) {
+int grpc_slice_buf_start_eq(grpc_slice a, const void* b, size_t len) {
   if (GRPC_SLICE_LENGTH(a) < len) return 0;
   return 0 == memcmp(GRPC_SLICE_START_PTR(a), b, len);
 }
 
 int grpc_slice_rchr(grpc_slice s, char c) {
-  const char *b = (const char *)GRPC_SLICE_START_PTR(s);
+  const char* b = (const char*)GRPC_SLICE_START_PTR(s);
   int i;
   for (i = (int)GRPC_SLICE_LENGTH(s) - 1; i != -1 && b[i] != c; i--)
     ;
@@ -452,16 +452,16 @@ int grpc_slice_rchr(grpc_slice s, char c) {
 }
 
 int grpc_slice_chr(grpc_slice s, char c) {
-  const char *b = (const char *)GRPC_SLICE_START_PTR(s);
-  const char *p = (const char *)memchr(b, c, GRPC_SLICE_LENGTH(s));
-  return p == NULL ? -1 : (int)(p - b);
+  const char* b = (const char*)GRPC_SLICE_START_PTR(s);
+  const char* p = (const char*)memchr(b, c, GRPC_SLICE_LENGTH(s));
+  return p == nullptr ? -1 : (int)(p - b);
 }
 
 int grpc_slice_slice(grpc_slice haystack, grpc_slice needle) {
   size_t haystack_len = GRPC_SLICE_LENGTH(haystack);
-  const uint8_t *haystack_bytes = GRPC_SLICE_START_PTR(haystack);
+  const uint8_t* haystack_bytes = GRPC_SLICE_START_PTR(haystack);
   size_t needle_len = GRPC_SLICE_LENGTH(needle);
-  const uint8_t *needle_bytes = GRPC_SLICE_START_PTR(needle);
+  const uint8_t* needle_bytes = GRPC_SLICE_START_PTR(needle);
 
   if (haystack_len == 0 || needle_len == 0) return -1;
   if (haystack_len < needle_len) return -1;
@@ -469,8 +469,8 @@ int grpc_slice_slice(grpc_slice haystack, grpc_slice needle) {
     return grpc_slice_eq(haystack, needle) ? 0 : -1;
   if (needle_len == 1) return grpc_slice_chr(haystack, (char)*needle_bytes);
 
-  const uint8_t *last = haystack_bytes + haystack_len - needle_len;
-  for (const uint8_t *cur = haystack_bytes; cur != last; ++cur) {
+  const uint8_t* last = haystack_bytes + haystack_len - needle_len;
+  for (const uint8_t* cur = haystack_bytes; cur != last; ++cur) {
     if (0 == memcmp(cur, needle_bytes, needle_len)) {
       return (int)(cur - haystack_bytes);
     }