grpc 0.12.0 → 0.13.0.pre1.1

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

@@ -54,23 +54,23 @@ typedef enum {
 
 typedef struct {
   grpc_chttp2_goaway_parse_state state;
-  gpr_uint32 last_stream_id;
-  gpr_uint32 error_code;
+  uint32_t last_stream_id;
+  uint32_t error_code;
   char *debug_data;
-  gpr_uint32 debug_length;
-  gpr_uint32 debug_pos;
+  uint32_t debug_length;
+  uint32_t debug_pos;
 } grpc_chttp2_goaway_parser;
 
 void grpc_chttp2_goaway_parser_init(grpc_chttp2_goaway_parser *p);
 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 *parser, gpr_uint32 length, gpr_uint8 flags);
+    grpc_chttp2_goaway_parser *parser, uint32_t length, uint8_t flags);
 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);
 
-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);
 

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

@@ -39,9 +39,9 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-gpr_slice grpc_chttp2_ping_create(gpr_uint8 ack, gpr_uint8 *opaque_8bytes) {
+gpr_slice grpc_chttp2_ping_create(uint8_t ack, uint8_t *opaque_8bytes) {
   gpr_slice slice = gpr_slice_malloc(9 + 8);
-  gpr_uint8 *p = GPR_SLICE_START_PTR(slice);
+  uint8_t *p = GPR_SLICE_START_PTR(slice);
 
   *p++ = 0;
   *p++ = 0;
@@ -58,7 +58,7 @@ gpr_slice grpc_chttp2_ping_create(gpr_uint8 ack, gpr_uint8 *opaque_8bytes) {
 }
 
 grpc_chttp2_parse_error grpc_chttp2_ping_parser_begin_frame(
-    grpc_chttp2_ping_parser *parser, gpr_uint32 length, gpr_uint8 flags) {
+    grpc_chttp2_ping_parser *parser, uint32_t length, uint8_t flags) {
   if (flags & 0xfe || length != 8) {
     gpr_log(GPR_ERROR, "invalid ping: length=%d, flags=%02x", length, flags);
     return GRPC_CHTTP2_CONNECTION_ERROR;
@@ -72,9 +72,9 @@ grpc_chttp2_parse_error grpc_chttp2_ping_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_ping_parser *p = parser;
 
   while (p->byte != 8 && cur != end) {

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

@@ -39,15 +39,15 @@
 #include "src/core/transport/chttp2/frame.h"
 
 typedef struct {
-  gpr_uint8 byte;
-  gpr_uint8 is_ack;
-  gpr_uint8 opaque_8bytes[8];
+  uint8_t byte;
+  uint8_t is_ack;
+  uint8_t opaque_8bytes[8];
 } grpc_chttp2_ping_parser;
 
-gpr_slice grpc_chttp2_ping_create(gpr_uint8 ack, gpr_uint8 *opaque_8bytes);
+gpr_slice grpc_chttp2_ping_create(uint8_t ack, uint8_t *opaque_8bytes);
 
 grpc_chttp2_parse_error grpc_chttp2_ping_parser_begin_frame(
-    grpc_chttp2_ping_parser *parser, gpr_uint32 length, gpr_uint8 flags);
+    grpc_chttp2_ping_parser *parser, uint32_t length, uint8_t flags);
 grpc_chttp2_parse_error grpc_chttp2_ping_parser_parse(
     grpc_exec_ctx *exec_ctx, void *parser,
     grpc_chttp2_transport_parsing *transport_parsing,

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

@@ -38,29 +38,29 @@
 
 #include "src/core/transport/chttp2/frame.h"
 
-gpr_slice grpc_chttp2_rst_stream_create(gpr_uint32 id, gpr_uint32 code) {
+gpr_slice grpc_chttp2_rst_stream_create(uint32_t id, uint32_t code) {
   gpr_slice slice = gpr_slice_malloc(13);
-  gpr_uint8 *p = GPR_SLICE_START_PTR(slice);
+  uint8_t *p = GPR_SLICE_START_PTR(slice);
 
   *p++ = 0;
   *p++ = 0;
   *p++ = 4;
   *p++ = GRPC_CHTTP2_FRAME_RST_STREAM;
   *p++ = 0;
-  *p++ = (gpr_uint8)(id >> 24);
-  *p++ = (gpr_uint8)(id >> 16);
-  *p++ = (gpr_uint8)(id >> 8);
-  *p++ = (gpr_uint8)(id);
-  *p++ = (gpr_uint8)(code >> 24);
-  *p++ = (gpr_uint8)(code >> 16);
-  *p++ = (gpr_uint8)(code >> 8);
-  *p++ = (gpr_uint8)(code);
+  *p++ = (uint8_t)(id >> 24);
+  *p++ = (uint8_t)(id >> 16);
+  *p++ = (uint8_t)(id >> 8);
+  *p++ = (uint8_t)(id);
+  *p++ = (uint8_t)(code >> 24);
+  *p++ = (uint8_t)(code >> 16);
+  *p++ = (uint8_t)(code >> 8);
+  *p++ = (uint8_t)(code);
 
   return slice;
 }
 
 grpc_chttp2_parse_error grpc_chttp2_rst_stream_parser_begin_frame(
-    grpc_chttp2_rst_stream_parser *parser, gpr_uint32 length, gpr_uint8 flags) {
+    grpc_chttp2_rst_stream_parser *parser, uint32_t length, uint8_t flags) {
   if (length != 4) {
     gpr_log(GPR_ERROR, "invalid rst_stream: length=%d, flags=%02x", length,
             flags);
@@ -74,9 +74,9 @@ grpc_chttp2_parse_error grpc_chttp2_rst_stream_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_rst_stream_parser *p = parser;
 
   while (p->byte != 4 && cur != end) {
@@ -89,11 +89,10 @@ grpc_chttp2_parse_error grpc_chttp2_rst_stream_parser_parse(
     GPR_ASSERT(is_last);
     stream_parsing->received_close = 1;
     stream_parsing->saw_rst_stream = 1;
-    stream_parsing->rst_stream_reason =
-        (((gpr_uint32)p->reason_bytes[0]) << 24) |
-        (((gpr_uint32)p->reason_bytes[1]) << 16) |
-        (((gpr_uint32)p->reason_bytes[2]) << 8) |
-        (((gpr_uint32)p->reason_bytes[3]));
+    stream_parsing->rst_stream_reason = (((uint32_t)p->reason_bytes[0]) << 24) |
+                                        (((uint32_t)p->reason_bytes[1]) << 16) |
+                                        (((uint32_t)p->reason_bytes[2]) << 8) |
+                                        (((uint32_t)p->reason_bytes[3]));
   }
 
   return GRPC_CHTTP2_PARSE_OK;

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

@@ -39,14 +39,14 @@
 #include "src/core/iomgr/exec_ctx.h"
 
 typedef struct {
-  gpr_uint8 byte;
-  gpr_uint8 reason_bytes[4];
+  uint8_t byte;
+  uint8_t reason_bytes[4];
 } grpc_chttp2_rst_stream_parser;
 
-gpr_slice grpc_chttp2_rst_stream_create(gpr_uint32 stream_id, gpr_uint32 code);
+gpr_slice grpc_chttp2_rst_stream_create(uint32_t stream_id, uint32_t code);
 
 grpc_chttp2_parse_error grpc_chttp2_rst_stream_parser_begin_frame(
-    grpc_chttp2_rst_stream_parser *parser, gpr_uint32 length, gpr_uint8 flags);
+    grpc_chttp2_rst_stream_parser *parser, uint32_t length, uint8_t flags);
 grpc_chttp2_parse_error grpc_chttp2_rst_stream_parser_parse(
     grpc_exec_ctx *exec_ctx, void *parser,
     grpc_chttp2_transport_parsing *transport_parsing,

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

@@ -67,11 +67,10 @@ const grpc_chttp2_setting_parameters
          GRPC_CHTTP2_PROTOCOL_ERROR},
 };
 
-static gpr_uint8 *fill_header(gpr_uint8 *out, gpr_uint32 length,
-                              gpr_uint8 flags) {
-  *out++ = (gpr_uint8)(length >> 16);
-  *out++ = (gpr_uint8)(length >> 8);
-  *out++ = (gpr_uint8)(length);
+static uint8_t *fill_header(uint8_t *out, uint32_t length, uint8_t flags) {
+  *out++ = (uint8_t)(length >> 16);
+  *out++ = (uint8_t)(length >> 8);
+  *out++ = (uint8_t)(length);
   *out++ = GRPC_CHTTP2_FRAME_SETTINGS;
   *out++ = flags;
   *out++ = 0;
@@ -81,12 +80,12 @@ static gpr_uint8 *fill_header(gpr_uint8 *out, gpr_uint32 length,
   return out;
 }
 
-gpr_slice grpc_chttp2_settings_create(gpr_uint32 *old, const gpr_uint32 *new,
-                                      gpr_uint32 force_mask, size_t count) {
+gpr_slice grpc_chttp2_settings_create(uint32_t *old, const uint32_t *new,
+                                      uint32_t force_mask, size_t count) {
   size_t i;
-  gpr_uint32 n = 0;
+  uint32_t n = 0;
   gpr_slice output;
-  gpr_uint8 *p;
+  uint8_t *p;
 
   for (i = 0; i < count; i++) {
     n += (new[i] != old[i] || (force_mask & (1u << i)) != 0);
@@ -98,12 +97,12 @@ gpr_slice grpc_chttp2_settings_create(gpr_uint32 *old, const gpr_uint32 *new,
   for (i = 0; i < count; i++) {
     if (new[i] != old[i] || (force_mask & (1u << i)) != 0) {
       GPR_ASSERT(i);
-      *p++ = (gpr_uint8)(i >> 8);
-      *p++ = (gpr_uint8)(i);
-      *p++ = (gpr_uint8)(new[i] >> 24);
-      *p++ = (gpr_uint8)(new[i] >> 16);
-      *p++ = (gpr_uint8)(new[i] >> 8);
-      *p++ = (gpr_uint8)(new[i]);
+      *p++ = (uint8_t)(i >> 8);
+      *p++ = (uint8_t)(i);
+      *p++ = (uint8_t)(new[i] >> 24);
+      *p++ = (uint8_t)(new[i] >> 16);
+      *p++ = (uint8_t)(new[i] >> 8);
+      *p++ = (uint8_t)(new[i]);
       old[i] = new[i];
     }
   }
@@ -120,11 +119,11 @@ gpr_slice grpc_chttp2_settings_ack_create(void) {
 }
 
 grpc_chttp2_parse_error grpc_chttp2_settings_parser_begin_frame(
-    grpc_chttp2_settings_parser *parser, gpr_uint32 length, gpr_uint8 flags,
-    gpr_uint32 *settings) {
+    grpc_chttp2_settings_parser *parser, uint32_t length, uint8_t flags,
+    uint32_t *settings) {
   parser->target_settings = settings;
   memcpy(parser->incoming_settings, settings,
-         GRPC_CHTTP2_NUM_SETTINGS * sizeof(gpr_uint32));
+         GRPC_CHTTP2_NUM_SETTINGS * sizeof(uint32_t));
   parser->is_ack = 0;
   parser->state = GRPC_CHTTP2_SPS_ID0;
   if (flags == GRPC_CHTTP2_FLAG_ACK) {
@@ -150,8 +149,8 @@ grpc_chttp2_parse_error grpc_chttp2_settings_parser_parse(
     grpc_chttp2_transport_parsing *transport_parsing,
     grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last) {
   grpc_chttp2_settings_parser *parser = p;
-  const gpr_uint8 *cur = GPR_SLICE_START_PTR(slice);
-  const gpr_uint8 *end = GPR_SLICE_END_PTR(slice);
+  const uint8_t *cur = GPR_SLICE_START_PTR(slice);
+  const uint8_t *end = GPR_SLICE_END_PTR(slice);
 
   if (parser->is_ack) {
     return GRPC_CHTTP2_PARSE_OK;
@@ -165,13 +164,13 @@ grpc_chttp2_parse_error grpc_chttp2_settings_parser_parse(
           if (is_last) {
             transport_parsing->settings_updated = 1;
             memcpy(parser->target_settings, parser->incoming_settings,
-                   GRPC_CHTTP2_NUM_SETTINGS * sizeof(gpr_uint32));
+                   GRPC_CHTTP2_NUM_SETTINGS * sizeof(uint32_t));
             gpr_slice_buffer_add(&transport_parsing->qbuf,
                                  grpc_chttp2_settings_ack_create());
           }
           return GRPC_CHTTP2_PARSE_OK;
         }
-        parser->id = (gpr_uint16)(((gpr_uint16)*cur) << 8);
+        parser->id = (uint16_t)(((uint16_t)*cur) << 8);
         cur++;
       /* fallthrough */
       case GRPC_CHTTP2_SPS_ID1:
@@ -179,7 +178,7 @@ grpc_chttp2_parse_error grpc_chttp2_settings_parser_parse(
           parser->state = GRPC_CHTTP2_SPS_ID1;
           return GRPC_CHTTP2_PARSE_OK;
         }
-        parser->id = (gpr_uint16)(parser->id | (*cur));
+        parser->id = (uint16_t)(parser->id | (*cur));
         cur++;
       /* fallthrough */
       case GRPC_CHTTP2_SPS_VAL0:
@@ -187,7 +186,7 @@ grpc_chttp2_parse_error grpc_chttp2_settings_parser_parse(
           parser->state = GRPC_CHTTP2_SPS_VAL0;
           return GRPC_CHTTP2_PARSE_OK;
         }
-        parser->value = ((gpr_uint32)*cur) << 24;
+        parser->value = ((uint32_t)*cur) << 24;
         cur++;
       /* fallthrough */
       case GRPC_CHTTP2_SPS_VAL1:
@@ -195,7 +194,7 @@ grpc_chttp2_parse_error grpc_chttp2_settings_parser_parse(
           parser->state = GRPC_CHTTP2_SPS_VAL1;
           return GRPC_CHTTP2_PARSE_OK;
         }
-        parser->value |= ((gpr_uint32)*cur) << 16;
+        parser->value |= ((uint32_t)*cur) << 16;
         cur++;
       /* fallthrough */
       case GRPC_CHTTP2_SPS_VAL2:
@@ -203,7 +202,7 @@ grpc_chttp2_parse_error grpc_chttp2_settings_parser_parse(
           parser->state = GRPC_CHTTP2_SPS_VAL2;
           return GRPC_CHTTP2_PARSE_OK;
         }
-        parser->value |= ((gpr_uint32)*cur) << 8;
+        parser->value |= ((uint32_t)*cur) << 8;
         cur++;
       /* fallthrough */
       case GRPC_CHTTP2_SPS_VAL3:
@@ -238,10 +237,11 @@ grpc_chttp2_parse_error grpc_chttp2_settings_parser_parse(
           if (parser->id == GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE &&
               parser->incoming_settings[parser->id] != parser->value) {
             transport_parsing->initial_window_update =
-                (gpr_int64)parser->value -
-                parser->incoming_settings[parser->id];
-            gpr_log(GPR_DEBUG, "adding %d for initial_window change",
-                    (int)transport_parsing->initial_window_update);
+                (int64_t)parser->value - parser->incoming_settings[parser->id];
+            if (grpc_http_trace) {
+              gpr_log(GPR_DEBUG, "adding %d for initial_window change",
+                      (int)transport_parsing->initial_window_update);
+            }
           }
           parser->incoming_settings[parser->id] = parser->value;
           if (grpc_http_trace) {

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

@@ -61,11 +61,11 @@ typedef enum {
 
 typedef struct {
   grpc_chttp2_settings_parse_state state;
-  gpr_uint32 *target_settings;
-  gpr_uint8 is_ack;
-  gpr_uint16 id;
-  gpr_uint32 value;
-  gpr_uint32 incoming_settings[GRPC_CHTTP2_NUM_SETTINGS];
+  uint32_t *target_settings;
+  uint8_t is_ack;
+  uint16_t id;
+  uint32_t value;
+  uint32_t incoming_settings[GRPC_CHTTP2_NUM_SETTINGS];
 } grpc_chttp2_settings_parser;
 
 typedef enum {
@@ -75,11 +75,11 @@ typedef enum {
 
 typedef struct {
   const char *name;
-  gpr_uint32 default_value;
-  gpr_uint32 min_value;
-  gpr_uint32 max_value;
+  uint32_t default_value;
+  uint32_t min_value;
+  uint32_t max_value;
   grpc_chttp2_invalid_value_behavior invalid_value_behavior;
-  gpr_uint32 error_value;
+  uint32_t error_value;
 } grpc_chttp2_setting_parameters;
 
 /* HTTP/2 mandated connection setting parameters */
@@ -87,14 +87,14 @@ extern const grpc_chttp2_setting_parameters
     grpc_chttp2_settings_parameters[GRPC_CHTTP2_NUM_SETTINGS];
 
 /* Create a settings frame by diffing old & new, and updating old to be new */
-gpr_slice grpc_chttp2_settings_create(gpr_uint32 *old, const gpr_uint32 *new,
-                                      gpr_uint32 force_mask, size_t count);
+gpr_slice grpc_chttp2_settings_create(uint32_t *old, const uint32_t *new,
+                                      uint32_t force_mask, size_t count);
 /* Create an ack settings frame */
 gpr_slice grpc_chttp2_settings_ack_create(void);
 
 grpc_chttp2_parse_error grpc_chttp2_settings_parser_begin_frame(
-    grpc_chttp2_settings_parser *parser, gpr_uint32 length, gpr_uint8 flags,
-    gpr_uint32 *settings);
+    grpc_chttp2_settings_parser *parser, uint32_t length, uint8_t flags,
+    uint32_t *settings);
 grpc_chttp2_parse_error grpc_chttp2_settings_parser_parse(
     grpc_exec_ctx *exec_ctx, void *parser,
     grpc_chttp2_transport_parsing *transport_parsing,

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

@@ -36,10 +36,10 @@
 
 #include <grpc/support/log.h>
 
-gpr_slice grpc_chttp2_window_update_create(gpr_uint32 id,
-                                           gpr_uint32 window_update) {
+gpr_slice grpc_chttp2_window_update_create(uint32_t id,
+                                           uint32_t window_update) {
   gpr_slice slice = gpr_slice_malloc(13);
-  gpr_uint8 *p = GPR_SLICE_START_PTR(slice);
+  uint8_t *p = GPR_SLICE_START_PTR(slice);
 
   GPR_ASSERT(window_update);
 
@@ -48,21 +48,20 @@ gpr_slice grpc_chttp2_window_update_create(gpr_uint32 id,
   *p++ = 4;
   *p++ = GRPC_CHTTP2_FRAME_WINDOW_UPDATE;
   *p++ = 0;
-  *p++ = (gpr_uint8)(id >> 24);
-  *p++ = (gpr_uint8)(id >> 16);
-  *p++ = (gpr_uint8)(id >> 8);
-  *p++ = (gpr_uint8)(id);
-  *p++ = (gpr_uint8)(window_update >> 24);
-  *p++ = (gpr_uint8)(window_update >> 16);
-  *p++ = (gpr_uint8)(window_update >> 8);
-  *p++ = (gpr_uint8)(window_update);
+  *p++ = (uint8_t)(id >> 24);
+  *p++ = (uint8_t)(id >> 16);
+  *p++ = (uint8_t)(id >> 8);
+  *p++ = (uint8_t)(id);
+  *p++ = (uint8_t)(window_update >> 24);
+  *p++ = (uint8_t)(window_update >> 16);
+  *p++ = (uint8_t)(window_update >> 8);
+  *p++ = (uint8_t)(window_update);
 
   return slice;
 }
 
 grpc_chttp2_parse_error grpc_chttp2_window_update_parser_begin_frame(
-    grpc_chttp2_window_update_parser *parser, gpr_uint32 length,
-    gpr_uint8 flags) {
+    grpc_chttp2_window_update_parser *parser, uint32_t length, uint8_t flags) {
   if (flags || length != 4) {
     gpr_log(GPR_ERROR, "invalid window update: length=%d, flags=%02x", length,
             flags);
@@ -77,19 +76,19 @@ grpc_chttp2_parse_error grpc_chttp2_window_update_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_window_update_parser *p = parser;
 
   while (p->byte != 4 && cur != end) {
-    p->amount |= ((gpr_uint32)*cur) << (8 * (3 - p->byte));
+    p->amount |= ((uint32_t)*cur) << (8 * (3 - p->byte));
     cur++;
     p->byte++;
   }
 
   if (p->byte == 4) {
-    gpr_uint32 received_update = p->amount;
+    uint32_t received_update = p->amount;
     if (received_update == 0 || (received_update & 0x80000000u)) {
       gpr_log(GPR_ERROR, "invalid window update bytes: %d", p->amount);
       return GRPC_CHTTP2_CONNECTION_ERROR;

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

@@ -39,17 +39,15 @@
 #include "src/core/transport/chttp2/frame.h"
 
 typedef struct {
-  gpr_uint8 byte;
-  gpr_uint8 is_connection_update;
-  gpr_uint32 amount;
+  uint8_t byte;
+  uint8_t is_connection_update;
+  uint32_t amount;
 } grpc_chttp2_window_update_parser;
 
-gpr_slice grpc_chttp2_window_update_create(gpr_uint32 id,
-                                           gpr_uint32 window_delta);
+gpr_slice grpc_chttp2_window_update_create(uint32_t id, uint32_t window_delta);
 
 grpc_chttp2_parse_error grpc_chttp2_window_update_parser_begin_frame(
-    grpc_chttp2_window_update_parser *parser, gpr_uint32 length,
-    gpr_uint8 flags);
+    grpc_chttp2_window_update_parser *parser, uint32_t length, uint8_t flags);
 grpc_chttp2_parse_error grpc_chttp2_window_update_parser_parse(
     grpc_exec_ctx *exec_ctx, void *parser,
     grpc_chttp2_transport_parsing *transport_parsing,