grpc 0.12.0 → 0.13.0.pre1.1

data/src/core/surface/server_create.c

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright 2015, Google Inc.
+ * Copyright 2015-2016, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -43,9 +43,6 @@ grpc_server *grpc_server_create(const grpc_channel_args *args, void *reserved) {
   const grpc_channel_filter *filters[3];
   size_t num_filters = 0;
   filters[num_filters++] = &grpc_compress_filter;
-  if (grpc_channel_args_is_census_enabled(args)) {
-    filters[num_filters++] = &grpc_server_census_filter;
-  }
   GRPC_API_TRACE("grpc_server_create(%p, %p)", 2, (args, reserved));
   return grpc_server_create_from_filters(filters, num_filters, args);
 }

data/src/core/surface/validate_metadata.c

@@ -36,7 +36,7 @@
 
 #include <grpc/support/port_platform.h>
 
-static int conforms_to(const char *s, size_t len, const gpr_uint8 *legal_bits) {
+static int conforms_to(const char *s, size_t len, const uint8_t *legal_bits) {
   const char *p = s;
   const char *e = s + len;
   for (; p != e; p++) {
@@ -49,7 +49,7 @@ static int conforms_to(const char *s, size_t len, const gpr_uint8 *legal_bits) {
 }
 
 int grpc_header_key_is_legal(const char *key, size_t length) {
-  static const gpr_uint8 legal_header_bits[256 / 8] = {
+  static const uint8_t legal_header_bits[256 / 8] = {
       0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0xff, 0x03, 0x00, 0x00, 0x00,
       0x80, 0xfe, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
@@ -60,7 +60,7 @@ int grpc_header_key_is_legal(const char *key, size_t length) {
 }
 
 int grpc_header_nonbin_value_is_legal(const char *value, size_t length) {
-  static const gpr_uint8 legal_header_bits[256 / 8] = {
+  static const uint8_t legal_header_bits[256 / 8] = {
       0x00, 0x00, 0x00, 0x00, 0xff, 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};

data/src/core/surface/version.c

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright 2015, Google Inc.
+ * Copyright 2015-2016, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -36,4 +36,4 @@
 
 #include <grpc/grpc.h>
 
-const char *grpc_version_string(void) { return "0.12.0.0"; }
+const char *grpc_version_string(void) { return "0.13.0-pre1"; }

data/src/core/transport/byte_stream.c

@@ -44,8 +44,9 @@ int grpc_byte_stream_next(grpc_exec_ctx *exec_ctx,
                            on_complete);
 }
 
-void grpc_byte_stream_destroy(grpc_byte_stream *byte_stream) {
-  byte_stream->destroy(byte_stream);
+void grpc_byte_stream_destroy(grpc_exec_ctx *exec_ctx,
+                              grpc_byte_stream *byte_stream) {
+  byte_stream->destroy(exec_ctx, byte_stream);
 }
 
 /* slice_buffer_stream */
@@ -61,13 +62,14 @@ static int slice_buffer_stream_next(grpc_exec_ctx *exec_ctx,
   return 1;
 }
 
-static void slice_buffer_stream_destroy(grpc_byte_stream *byte_stream) {}
+static void slice_buffer_stream_destroy(grpc_exec_ctx *exec_ctx,
+                                        grpc_byte_stream *byte_stream) {}
 
 void grpc_slice_buffer_stream_init(grpc_slice_buffer_stream *stream,
                                    gpr_slice_buffer *slice_buffer,
-                                   gpr_uint32 flags) {
-  GPR_ASSERT(slice_buffer->length <= GPR_UINT32_MAX);
-  stream->base.length = (gpr_uint32)slice_buffer->length;
+                                   uint32_t flags) {
+  GPR_ASSERT(slice_buffer->length <= UINT32_MAX);
+  stream->base.length = (uint32_t)slice_buffer->length;
   stream->base.flags = flags;
   stream->base.next = slice_buffer_stream_next;
   stream->base.destroy = slice_buffer_stream_destroy;

data/src/core/transport/byte_stream.h

@@ -47,12 +47,12 @@ struct grpc_byte_stream;
 typedef struct grpc_byte_stream grpc_byte_stream;
 
 struct grpc_byte_stream {
-  gpr_uint32 length;
-  gpr_uint32 flags;
+  uint32_t length;
+  uint32_t flags;
   int (*next)(grpc_exec_ctx *exec_ctx, grpc_byte_stream *byte_stream,
               gpr_slice *slice, size_t max_size_hint,
               grpc_closure *on_complete);
-  void (*destroy)(grpc_byte_stream *byte_stream);
+  void (*destroy)(grpc_exec_ctx *exec_ctx, grpc_byte_stream *byte_stream);
 };
 
 /* returns 1 if the bytes are available immediately (in which case
@@ -72,7 +72,8 @@ int grpc_byte_stream_next(grpc_exec_ctx *exec_ctx,
                           grpc_byte_stream *byte_stream, gpr_slice *slice,
                           size_t max_size_hint, grpc_closure *on_complete);
 
-void grpc_byte_stream_destroy(grpc_byte_stream *byte_stream);
+void grpc_byte_stream_destroy(grpc_exec_ctx *exec_ctx,
+                              grpc_byte_stream *byte_stream);
 
 /* grpc_byte_stream that wraps a slice buffer */
 typedef struct grpc_slice_buffer_stream {
@@ -83,6 +84,6 @@ typedef struct grpc_slice_buffer_stream {
 
 void grpc_slice_buffer_stream_init(grpc_slice_buffer_stream *stream,
                                    gpr_slice_buffer *slice_buffer,
-                                   gpr_uint32 flags);
+                                   uint32_t flags);
 
 #endif /* GRPC_INTERNAL_CORE_TRANSPORT_BYTE_STREAM_H */

data/src/core/transport/chttp2/bin_encoder.c

@@ -42,8 +42,8 @@ static const char alphabet[] =
     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
 typedef struct {
-  gpr_uint16 bits;
-  gpr_uint8 length;
+  uint16_t bits;
+  uint8_t length;
 } b64_huff_sym;
 
 static const b64_huff_sym huff_alphabet[64] = {{0x21, 6},
@@ -111,7 +111,7 @@ static const b64_huff_sym huff_alphabet[64] = {{0x21, 6},
                                                {0x7fb, 11},
                                                {0x18, 6}};
 
-static const gpr_uint8 tail_xtra[3] = {0, 2, 3};
+static const uint8_t tail_xtra[3] = {0, 2, 3};
 
 gpr_slice grpc_chttp2_base64_encode(gpr_slice input) {
   size_t input_length = GPR_SLICE_LENGTH(input);
@@ -119,7 +119,7 @@ gpr_slice grpc_chttp2_base64_encode(gpr_slice input) {
   size_t tail_case = input_length % 3;
   size_t output_length = input_triplets * 4 + tail_xtra[tail_case];
   gpr_slice output = gpr_slice_malloc(output_length);
-  gpr_uint8 *in = GPR_SLICE_START_PTR(input);
+  uint8_t *in = GPR_SLICE_START_PTR(input);
   char *out = (char *)GPR_SLICE_START_PTR(output);
   size_t i;
 
@@ -159,11 +159,11 @@ gpr_slice grpc_chttp2_base64_encode(gpr_slice input) {
 
 gpr_slice grpc_chttp2_huffman_compress(gpr_slice input) {
   size_t nbits;
-  gpr_uint8 *in;
-  gpr_uint8 *out;
+  uint8_t *in;
+  uint8_t *out;
   gpr_slice output;
-  gpr_uint32 temp = 0;
-  gpr_uint32 temp_length = 0;
+  uint32_t temp = 0;
+  uint32_t temp_length = 0;
 
   nbits = 0;
   for (in = GPR_SLICE_START_PTR(input); in != GPR_SLICE_END_PTR(input); ++in) {
@@ -180,7 +180,7 @@ gpr_slice grpc_chttp2_huffman_compress(gpr_slice input) {
 
     while (temp_length > 8) {
       temp_length -= 8;
-      *out++ = (gpr_uint8)(temp >> temp_length);
+      *out++ = (uint8_t)(temp >> temp_length);
     }
   }
 
@@ -189,8 +189,8 @@ gpr_slice grpc_chttp2_huffman_compress(gpr_slice input) {
      * expanded form due to the "integral promotion" performed (see section
      * 3.2.1.1 of the C89 draft standard). A cast to the smaller container type
      * is then required to avoid the compiler warning */
-    *out++ = (gpr_uint8)((gpr_uint8)(temp << (8u - temp_length)) |
-                         (gpr_uint8)(0xffu >> temp_length));
+    *out++ = (uint8_t)((uint8_t)(temp << (8u - temp_length)) |
+                       (uint8_t)(0xffu >> temp_length));
   }
 
   GPR_ASSERT(out == GPR_SLICE_END_PTR(output));
@@ -199,28 +199,28 @@ gpr_slice grpc_chttp2_huffman_compress(gpr_slice input) {
 }
 
 typedef struct {
-  gpr_uint32 temp;
-  gpr_uint32 temp_length;
-  gpr_uint8 *out;
+  uint32_t temp;
+  uint32_t temp_length;
+  uint8_t *out;
 } huff_out;
 
 static void enc_flush_some(huff_out *out) {
   while (out->temp_length > 8) {
     out->temp_length -= 8;
-    *out->out++ = (gpr_uint8)(out->temp >> out->temp_length);
+    *out->out++ = (uint8_t)(out->temp >> out->temp_length);
   }
 }
 
-static void enc_add2(huff_out *out, gpr_uint8 a, gpr_uint8 b) {
+static void enc_add2(huff_out *out, uint8_t a, uint8_t b) {
   b64_huff_sym sa = huff_alphabet[a];
   b64_huff_sym sb = huff_alphabet[b];
   out->temp = (out->temp << (sa.length + sb.length)) |
-              ((gpr_uint32)sa.bits << sb.length) | sb.bits;
-  out->temp_length += (gpr_uint32)sa.length + (gpr_uint32)sb.length;
+              ((uint32_t)sa.bits << sb.length) | sb.bits;
+  out->temp_length += (uint32_t)sa.length + (uint32_t)sb.length;
   enc_flush_some(out);
 }
 
-static void enc_add1(huff_out *out, gpr_uint8 a) {
+static void enc_add1(huff_out *out, uint8_t a) {
   b64_huff_sym sa = huff_alphabet[a];
   out->temp = (out->temp << sa.length) | sa.bits;
   out->temp_length += sa.length;
@@ -235,8 +235,8 @@ gpr_slice grpc_chttp2_base64_encode_and_huffman_compress(gpr_slice input) {
   size_t max_output_bits = 11 * output_syms;
   size_t max_output_length = max_output_bits / 8 + (max_output_bits % 8 != 0);
   gpr_slice output = gpr_slice_malloc(max_output_length);
-  gpr_uint8 *in = GPR_SLICE_START_PTR(input);
-  gpr_uint8 *start_out = GPR_SLICE_START_PTR(output);
+  uint8_t *in = GPR_SLICE_START_PTR(input);
+  uint8_t *start_out = GPR_SLICE_START_PTR(output);
   huff_out out;
   size_t i;
 
@@ -246,9 +246,9 @@ gpr_slice grpc_chttp2_base64_encode_and_huffman_compress(gpr_slice input) {
 
   /* encode full triplets */
   for (i = 0; i < input_triplets; i++) {
-    enc_add2(&out, in[0] >> 2, (gpr_uint8)((in[0] & 0x3) << 4) | (in[1] >> 4));
-    enc_add2(&out, (gpr_uint8)((in[1] & 0xf) << 2) | (in[2] >> 6),
-             (gpr_uint8)(in[2] & 0x3f));
+    enc_add2(&out, in[0] >> 2, (uint8_t)((in[0] & 0x3) << 4) | (in[1] >> 4));
+    enc_add2(&out, (uint8_t)((in[1] & 0xf) << 2) | (in[2] >> 6),
+             (uint8_t)(in[2] & 0x3f));
     in += 3;
   }
 
@@ -257,13 +257,13 @@ gpr_slice grpc_chttp2_base64_encode_and_huffman_compress(gpr_slice input) {
     case 0:
       break;
     case 1:
-      enc_add2(&out, in[0] >> 2, (gpr_uint8)((in[0] & 0x3) << 4));
+      enc_add2(&out, in[0] >> 2, (uint8_t)((in[0] & 0x3) << 4));
       in += 1;
       break;
     case 2:
       enc_add2(&out, in[0] >> 2,
-               (gpr_uint8)((in[0] & 0x3) << 4) | (gpr_uint8)(in[1] >> 4));
-      enc_add1(&out, (gpr_uint8)((in[1] & 0xf) << 2));
+               (uint8_t)((in[0] & 0x3) << 4) | (uint8_t)(in[1] >> 4));
+      enc_add1(&out, (uint8_t)((in[1] & 0xf) << 2));
       in += 2;
       break;
   }
@@ -273,8 +273,8 @@ gpr_slice grpc_chttp2_base64_encode_and_huffman_compress(gpr_slice input) {
      * expanded form due to the "integral promotion" performed (see section
      * 3.2.1.1 of the C89 draft standard). A cast to the smaller container type
      * is then required to avoid the compiler warning */
-    *out.out++ = (gpr_uint8)((gpr_uint8)(out.temp << (8u - out.temp_length)) |
-                             (gpr_uint8)(0xffu >> out.temp_length));
+    *out.out++ = (uint8_t)((uint8_t)(out.temp << (8u - out.temp_length)) |
+                           (uint8_t)(0xffu >> out.temp_length));
   }
 
   GPR_ASSERT(out.out <= GPR_SLICE_END_PTR(output));

data/src/core/transport/chttp2/frame_data.c

@@ -53,16 +53,17 @@ void grpc_chttp2_data_parser_destroy(grpc_exec_ctx *exec_ctx,
                                      grpc_chttp2_data_parser *parser) {
   grpc_byte_stream *bs;
   if (parser->parsing_frame) {
-    grpc_chttp2_incoming_byte_stream_finished(exec_ctx, parser->parsing_frame);
+    grpc_chttp2_incoming_byte_stream_finished(exec_ctx, parser->parsing_frame,
+                                              0, 1);
   }
   while (
       (bs = grpc_chttp2_incoming_frame_queue_pop(&parser->incoming_frames))) {
-    grpc_byte_stream_destroy(bs);
+    grpc_byte_stream_destroy(exec_ctx, bs);
   }
 }
 
 grpc_chttp2_parse_error grpc_chttp2_data_parser_begin_frame(
-    grpc_chttp2_data_parser *parser, gpr_uint8 flags) {
+    grpc_chttp2_data_parser *parser, uint8_t flags) {
   if (flags & ~GRPC_CHTTP2_DATA_FLAG_END_STREAM) {
     gpr_log(GPR_ERROR, "unsupported data flags: 0x%02x", flags);
     return GRPC_CHTTP2_STREAM_ERROR;
@@ -110,24 +111,24 @@ grpc_byte_stream *grpc_chttp2_incoming_frame_queue_pop(
   return out;
 }
 
-void grpc_chttp2_encode_data(gpr_uint32 id, gpr_slice_buffer *inbuf,
-                             gpr_uint32 write_bytes, int is_eof,
+void grpc_chttp2_encode_data(uint32_t id, gpr_slice_buffer *inbuf,
+                             uint32_t write_bytes, int is_eof,
                              gpr_slice_buffer *outbuf) {
   gpr_slice hdr;
-  gpr_uint8 *p;
+  uint8_t *p;
 
   hdr = gpr_slice_malloc(9);
   p = GPR_SLICE_START_PTR(hdr);
   GPR_ASSERT(write_bytes < (1 << 24));
-  *p++ = (gpr_uint8)(write_bytes >> 16);
-  *p++ = (gpr_uint8)(write_bytes >> 8);
-  *p++ = (gpr_uint8)(write_bytes);
+  *p++ = (uint8_t)(write_bytes >> 16);
+  *p++ = (uint8_t)(write_bytes >> 8);
+  *p++ = (uint8_t)(write_bytes);
   *p++ = GRPC_CHTTP2_FRAME_DATA;
   *p++ = is_eof ? GRPC_CHTTP2_DATA_FLAG_END_STREAM : 0;
-  *p++ = (gpr_uint8)(id >> 24);
-  *p++ = (gpr_uint8)(id >> 16);
-  *p++ = (gpr_uint8)(id >> 8);
-  *p++ = (gpr_uint8)(id);
+  *p++ = (uint8_t)(id >> 24);
+  *p++ = (uint8_t)(id >> 16);
+  *p++ = (uint8_t)(id >> 8);
+  *p++ = (uint8_t)(id);
   gpr_slice_buffer_add(outbuf, hdr);
 
   gpr_slice_buffer_move_first(inbuf, write_bytes, outbuf);
@@ -137,11 +138,11 @@ grpc_chttp2_parse_error grpc_chttp2_data_parser_parse(
     grpc_exec_ctx *exec_ctx, void *parser,
     grpc_chttp2_transport_parsing *transport_parsing,
     grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last) {
-  gpr_uint8 *const beg = GPR_SLICE_START_PTR(slice);
-  gpr_uint8 *const end = GPR_SLICE_END_PTR(slice);
-  gpr_uint8 *cur = beg;
+  uint8_t *const beg = GPR_SLICE_START_PTR(slice);
+  uint8_t *const end = GPR_SLICE_END_PTR(slice);
+  uint8_t *cur = beg;
   grpc_chttp2_data_parser *p = parser;
-  gpr_uint32 message_flags;
+  uint32_t message_flags;
   grpc_chttp2_incoming_byte_stream *incoming_byte_stream;
 
   if (is_last && p->is_last_frame) {
@@ -173,28 +174,28 @@ grpc_chttp2_parse_error grpc_chttp2_data_parser_parse(
       }
     /* fallthrough */
     case GRPC_CHTTP2_DATA_FH_1:
-      p->frame_size = ((gpr_uint32)*cur) << 24;
+      p->frame_size = ((uint32_t)*cur) << 24;
       if (++cur == end) {
         p->state = GRPC_CHTTP2_DATA_FH_2;
         return GRPC_CHTTP2_PARSE_OK;
       }
     /* fallthrough */
     case GRPC_CHTTP2_DATA_FH_2:
-      p->frame_size |= ((gpr_uint32)*cur) << 16;
+      p->frame_size |= ((uint32_t)*cur) << 16;
       if (++cur == end) {
         p->state = GRPC_CHTTP2_DATA_FH_3;
         return GRPC_CHTTP2_PARSE_OK;
       }
     /* fallthrough */
     case GRPC_CHTTP2_DATA_FH_3:
-      p->frame_size |= ((gpr_uint32)*cur) << 8;
+      p->frame_size |= ((uint32_t)*cur) << 8;
       if (++cur == end) {
         p->state = GRPC_CHTTP2_DATA_FH_4;
         return GRPC_CHTTP2_PARSE_OK;
       }
     /* fallthrough */
     case GRPC_CHTTP2_DATA_FH_4:
-      p->frame_size |= ((gpr_uint32)*cur);
+      p->frame_size |= ((uint32_t)*cur);
       p->state = GRPC_CHTTP2_DATA_FRAME;
       ++cur;
       message_flags = 0;
@@ -214,20 +215,22 @@ grpc_chttp2_parse_error grpc_chttp2_data_parser_parse(
       }
       grpc_chttp2_list_add_parsing_seen_stream(transport_parsing,
                                                stream_parsing);
-      if ((gpr_uint32)(end - cur) == p->frame_size) {
+      if ((uint32_t)(end - cur) == p->frame_size) {
         grpc_chttp2_incoming_byte_stream_push(
             exec_ctx, p->parsing_frame,
             gpr_slice_sub(slice, (size_t)(cur - beg), (size_t)(end - beg)));
-        grpc_chttp2_incoming_byte_stream_finished(exec_ctx, p->parsing_frame);
+        grpc_chttp2_incoming_byte_stream_finished(exec_ctx, p->parsing_frame, 1,
+                                                  1);
         p->parsing_frame = NULL;
         p->state = GRPC_CHTTP2_DATA_FH_0;
         return GRPC_CHTTP2_PARSE_OK;
-      } else if ((gpr_uint32)(end - cur) > p->frame_size) {
+      } else if ((uint32_t)(end - cur) > p->frame_size) {
         grpc_chttp2_incoming_byte_stream_push(
             exec_ctx, p->parsing_frame,
             gpr_slice_sub(slice, (size_t)(cur - beg),
                           (size_t)(cur + p->frame_size - beg)));
-        grpc_chttp2_incoming_byte_stream_finished(exec_ctx, p->parsing_frame);
+        grpc_chttp2_incoming_byte_stream_finished(exec_ctx, p->parsing_frame, 1,
+                                                  1);
         p->parsing_frame = NULL;
         cur += p->frame_size;
         goto fh_0; /* loop */
@@ -236,7 +239,7 @@ grpc_chttp2_parse_error grpc_chttp2_data_parser_parse(
             exec_ctx, p->parsing_frame,
             gpr_slice_sub(slice, (size_t)(cur - beg), (size_t)(end - beg)));
         GPR_ASSERT((size_t)(end - cur) <= p->frame_size);
-        p->frame_size -= (gpr_uint32)(end - cur);
+        p->frame_size -= (uint32_t)(end - cur);
         return GRPC_CHTTP2_PARSE_OK;
       }
   }

data/src/core/transport/chttp2/frame_data.h

@@ -61,9 +61,9 @@ typedef struct grpc_chttp2_incoming_frame_queue {
 
 typedef struct {
   grpc_chttp2_stream_state state;
-  gpr_uint8 is_last_frame;
-  gpr_uint8 frame_type;
-  gpr_uint32 frame_size;
+  uint8_t is_last_frame;
+  uint8_t frame_type;
+  uint32_t frame_size;
 
   int is_frame_compressed;
   grpc_chttp2_incoming_frame_queue incoming_frames;
@@ -85,7 +85,7 @@ void grpc_chttp2_data_parser_destroy(grpc_exec_ctx *exec_ctx,
 
 /* start processing a new data frame */
 grpc_chttp2_parse_error grpc_chttp2_data_parser_begin_frame(
-    grpc_chttp2_data_parser *parser, gpr_uint8 flags);
+    grpc_chttp2_data_parser *parser, uint8_t flags);
 
 /* handle a slice of a data frame - is_last indicates the last slice of a
    frame */
@@ -94,8 +94,8 @@ grpc_chttp2_parse_error grpc_chttp2_data_parser_parse(
     grpc_chttp2_transport_parsing *transport_parsing,
     grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last);
 
-void grpc_chttp2_encode_data(gpr_uint32 id, gpr_slice_buffer *inbuf,
-                             gpr_uint32 write_bytes, int is_eof,
+void grpc_chttp2_encode_data(uint32_t id, gpr_slice_buffer *inbuf,
+                             uint32_t write_bytes, int is_eof,
                              gpr_slice_buffer *outbuf);
 
 #endif /* GRPC_INTERNAL_CORE_TRANSPORT_CHTTP2_FRAME_DATA_H */

data/src/core/transport/chttp2/frame_goaway.c

@@ -48,7 +48,7 @@ void grpc_chttp2_goaway_parser_destroy(grpc_chttp2_goaway_parser *p) {
 }
 
 grpc_chttp2_parse_error grpc_chttp2_goaway_parser_begin_frame(
-    grpc_chttp2_goaway_parser *p, gpr_uint32 length, gpr_uint8 flags) {
+    grpc_chttp2_goaway_parser *p, uint32_t length, uint8_t flags) {
   if (length < 8) {
     gpr_log(GPR_ERROR, "goaway frame too short (%d bytes)", length);
     return GRPC_CHTTP2_CONNECTION_ERROR;
@@ -66,9 +66,9 @@ grpc_chttp2_parse_error grpc_chttp2_goaway_parser_parse(
     grpc_exec_ctx *exec_ctx, void *parser,
     grpc_chttp2_transport_parsing *transport_parsing,
     grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last) {
-  gpr_uint8 *const beg = GPR_SLICE_START_PTR(slice);
-  gpr_uint8 *const end = GPR_SLICE_END_PTR(slice);
-  gpr_uint8 *cur = beg;
+  uint8_t *const beg = GPR_SLICE_START_PTR(slice);
+  uint8_t *const end = GPR_SLICE_END_PTR(slice);
+  uint8_t *cur = beg;
   grpc_chttp2_goaway_parser *p = parser;
 
   switch (p->state) {
@@ -77,7 +77,7 @@ grpc_chttp2_parse_error grpc_chttp2_goaway_parser_parse(
         p->state = GRPC_CHTTP2_GOAWAY_LSI0;
         return GRPC_CHTTP2_PARSE_OK;
       }
-      p->last_stream_id = ((gpr_uint32)*cur) << 24;
+      p->last_stream_id = ((uint32_t)*cur) << 24;
       ++cur;
     /* fallthrough */
     case GRPC_CHTTP2_GOAWAY_LSI1:
@@ -85,7 +85,7 @@ grpc_chttp2_parse_error grpc_chttp2_goaway_parser_parse(
         p->state = GRPC_CHTTP2_GOAWAY_LSI1;
         return GRPC_CHTTP2_PARSE_OK;
       }
-      p->last_stream_id |= ((gpr_uint32)*cur) << 16;
+      p->last_stream_id |= ((uint32_t)*cur) << 16;
       ++cur;
     /* fallthrough */
     case GRPC_CHTTP2_GOAWAY_LSI2:
@@ -93,7 +93,7 @@ grpc_chttp2_parse_error grpc_chttp2_goaway_parser_parse(
         p->state = GRPC_CHTTP2_GOAWAY_LSI2;
         return GRPC_CHTTP2_PARSE_OK;
       }
-      p->last_stream_id |= ((gpr_uint32)*cur) << 8;
+      p->last_stream_id |= ((uint32_t)*cur) << 8;
       ++cur;
     /* fallthrough */
     case GRPC_CHTTP2_GOAWAY_LSI3:
@@ -101,7 +101,7 @@ grpc_chttp2_parse_error grpc_chttp2_goaway_parser_parse(
         p->state = GRPC_CHTTP2_GOAWAY_LSI3;
         return GRPC_CHTTP2_PARSE_OK;
       }
-      p->last_stream_id |= ((gpr_uint32)*cur);
+      p->last_stream_id |= ((uint32_t)*cur);
       ++cur;
     /* fallthrough */
     case GRPC_CHTTP2_GOAWAY_ERR0:
@@ -109,7 +109,7 @@ grpc_chttp2_parse_error grpc_chttp2_goaway_parser_parse(
         p->state = GRPC_CHTTP2_GOAWAY_ERR0;
         return GRPC_CHTTP2_PARSE_OK;
       }
-      p->error_code = ((gpr_uint32)*cur) << 24;
+      p->error_code = ((uint32_t)*cur) << 24;
       ++cur;
     /* fallthrough */
     case GRPC_CHTTP2_GOAWAY_ERR1:
@@ -117,7 +117,7 @@ grpc_chttp2_parse_error grpc_chttp2_goaway_parser_parse(
         p->state = GRPC_CHTTP2_GOAWAY_ERR1;
         return GRPC_CHTTP2_PARSE_OK;
       }
-      p->error_code |= ((gpr_uint32)*cur) << 16;
+      p->error_code |= ((uint32_t)*cur) << 16;
       ++cur;
     /* fallthrough */
     case GRPC_CHTTP2_GOAWAY_ERR2:
@@ -125,7 +125,7 @@ grpc_chttp2_parse_error grpc_chttp2_goaway_parser_parse(
         p->state = GRPC_CHTTP2_GOAWAY_ERR2;
         return GRPC_CHTTP2_PARSE_OK;
       }
-      p->error_code |= ((gpr_uint32)*cur) << 8;
+      p->error_code |= ((uint32_t)*cur) << 8;
       ++cur;
     /* fallthrough */
     case GRPC_CHTTP2_GOAWAY_ERR3:
@@ -133,13 +133,13 @@ grpc_chttp2_parse_error grpc_chttp2_goaway_parser_parse(
         p->state = GRPC_CHTTP2_GOAWAY_ERR3;
         return GRPC_CHTTP2_PARSE_OK;
       }
-      p->error_code |= ((gpr_uint32)*cur);
+      p->error_code |= ((uint32_t)*cur);
       ++cur;
     /* fallthrough */
     case GRPC_CHTTP2_GOAWAY_DEBUG:
       memcpy(p->debug_data + p->debug_pos, cur, (size_t)(end - cur));
-      GPR_ASSERT((size_t)(end - cur) < GPR_UINT32_MAX - p->debug_pos);
-      p->debug_pos += (gpr_uint32)(end - cur);
+      GPR_ASSERT((size_t)(end - cur) < UINT32_MAX - p->debug_pos);
+      p->debug_pos += (uint32_t)(end - cur);
       p->state = GRPC_CHTTP2_GOAWAY_DEBUG;
       if (is_last) {
         transport_parsing->goaway_received = 1;
@@ -155,19 +155,19 @@ grpc_chttp2_parse_error grpc_chttp2_goaway_parser_parse(
   GPR_UNREACHABLE_CODE(return GRPC_CHTTP2_CONNECTION_ERROR);
 }
 
-void grpc_chttp2_goaway_append(gpr_uint32 last_stream_id, gpr_uint32 error_code,
+void grpc_chttp2_goaway_append(uint32_t last_stream_id, uint32_t error_code,
                                gpr_slice debug_data,
                                gpr_slice_buffer *slice_buffer) {
   gpr_slice header = gpr_slice_malloc(9 + 4 + 4);
-  gpr_uint8 *p = GPR_SLICE_START_PTR(header);
-  gpr_uint32 frame_length;
-  GPR_ASSERT(GPR_SLICE_LENGTH(debug_data) < GPR_UINT32_MAX - 4 - 4);
-  frame_length = 4 + 4 + (gpr_uint32)GPR_SLICE_LENGTH(debug_data);
+  uint8_t *p = GPR_SLICE_START_PTR(header);
+  uint32_t frame_length;
+  GPR_ASSERT(GPR_SLICE_LENGTH(debug_data) < UINT32_MAX - 4 - 4);
+  frame_length = 4 + 4 + (uint32_t)GPR_SLICE_LENGTH(debug_data);
 
   /* frame header: length */
-  *p++ = (gpr_uint8)(frame_length >> 16);
-  *p++ = (gpr_uint8)(frame_length >> 8);
-  *p++ = (gpr_uint8)(frame_length);
+  *p++ = (uint8_t)(frame_length >> 16);
+  *p++ = (uint8_t)(frame_length >> 8);
+  *p++ = (uint8_t)(frame_length);
   /* frame header: type */
   *p++ = GRPC_CHTTP2_FRAME_GOAWAY;
   /* frame header: flags */
@@ -178,15 +178,15 @@ void grpc_chttp2_goaway_append(gpr_uint32 last_stream_id, gpr_uint32 error_code,
   *p++ = 0;
   *p++ = 0;
   /* payload: last stream id */
-  *p++ = (gpr_uint8)(last_stream_id >> 24);
-  *p++ = (gpr_uint8)(last_stream_id >> 16);
-  *p++ = (gpr_uint8)(last_stream_id >> 8);
-  *p++ = (gpr_uint8)(last_stream_id);
+  *p++ = (uint8_t)(last_stream_id >> 24);
+  *p++ = (uint8_t)(last_stream_id >> 16);
+  *p++ = (uint8_t)(last_stream_id >> 8);
+  *p++ = (uint8_t)(last_stream_id);
   /* payload: error code */
-  *p++ = (gpr_uint8)(error_code >> 24);
-  *p++ = (gpr_uint8)(error_code >> 16);
-  *p++ = (gpr_uint8)(error_code >> 8);
-  *p++ = (gpr_uint8)(error_code);
+  *p++ = (uint8_t)(error_code >> 24);
+  *p++ = (uint8_t)(error_code >> 16);
+  *p++ = (uint8_t)(error_code >> 8);
+  *p++ = (uint8_t)(error_code);
   GPR_ASSERT(p == GPR_SLICE_END_PTR(header));
   gpr_slice_buffer_add(slice_buffer, header);
   gpr_slice_buffer_add(slice_buffer, debug_data);