awesome-grpc-that-works 0.12.2 → 0.14.0.dev

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

@@ -126,7 +126,7 @@ void grpc_chttp2_publish_reads(
   if (transport_parsing->settings_ack_received) {
     memcpy(transport_global->settings[GRPC_ACKED_SETTINGS],
            transport_global->settings[GRPC_SENT_SETTINGS],
-           GRPC_CHTTP2_NUM_SETTINGS * sizeof(gpr_uint32));
+           GRPC_CHTTP2_NUM_SETTINGS * sizeof(uint32_t));
     transport_parsing->settings_ack_received = 0;
     transport_global->sent_local_settings = 0;
   }
@@ -135,7 +135,7 @@ void grpc_chttp2_publish_reads(
      published later */
   if (transport_parsing->goaway_received) {
     grpc_chttp2_add_incoming_goaway(exec_ctx, transport_global,
-                                    (gpr_uint32)transport_parsing->goaway_error,
+                                    (uint32_t)transport_parsing->goaway_error,
                                     transport_parsing->goaway_text);
     transport_parsing->goaway_text = gpr_empty_slice();
     transport_parsing->goaway_received = 0;
@@ -155,8 +155,8 @@ void grpc_chttp2_publish_reads(
 
   if (transport_parsing->incoming_window <
       transport_global->connection_window_target * 3 / 4) {
-    gpr_int64 announce_bytes = transport_global->connection_window_target -
-                               transport_parsing->incoming_window;
+    int64_t announce_bytes = transport_global->connection_window_target -
+                             transport_parsing->incoming_window;
     GRPC_CHTTP2_FLOW_CREDIT_TRANSPORT("parsed", transport_global,
                                       announce_incoming_window, announce_bytes);
     GRPC_CHTTP2_FLOW_CREDIT_TRANSPORT("parsed", transport_parsing,
@@ -181,7 +181,7 @@ void grpc_chttp2_publish_reads(
       grpc_chttp2_list_add_writable_stream(transport_global, stream_global);
     }
 
-    stream_global->max_recv_bytes -= (gpr_uint32)GPR_MIN(
+    stream_global->max_recv_bytes -= (uint32_t)GPR_MIN(
         stream_global->max_recv_bytes, stream_parsing->received_bytes);
     stream_parsing->received_bytes = 0;
 
@@ -245,9 +245,9 @@ void grpc_chttp2_publish_reads(
 int grpc_chttp2_perform_read(grpc_exec_ctx *exec_ctx,
                              grpc_chttp2_transport_parsing *transport_parsing,
                              gpr_slice slice) {
-  gpr_uint8 *beg = GPR_SLICE_START_PTR(slice);
-  gpr_uint8 *end = GPR_SLICE_END_PTR(slice);
-  gpr_uint8 *cur = beg;
+  uint8_t *beg = GPR_SLICE_START_PTR(slice);
+  uint8_t *end = GPR_SLICE_END_PTR(slice);
+  uint8_t *cur = beg;
 
   if (cur == end) return 1;
 
@@ -284,7 +284,7 @@ int grpc_chttp2_perform_read(grpc_exec_ctx *exec_ctx,
                   "at byte %d",
                   GRPC_CHTTP2_CLIENT_CONNECT_STRING[transport_parsing
                                                         ->deframe_state],
-                  (int)(gpr_uint8)GRPC_CHTTP2_CLIENT_CONNECT_STRING
+                  (int)(uint8_t)GRPC_CHTTP2_CLIENT_CONNECT_STRING
                       [transport_parsing->deframe_state],
                   *cur, (int)*cur, transport_parsing->deframe_state);
           return 0;
@@ -299,7 +299,7 @@ int grpc_chttp2_perform_read(grpc_exec_ctx *exec_ctx,
     dts_fh_0:
     case GRPC_DTS_FH_0:
       GPR_ASSERT(cur < end);
-      transport_parsing->incoming_frame_size = ((gpr_uint32)*cur) << 16;
+      transport_parsing->incoming_frame_size = ((uint32_t)*cur) << 16;
       if (++cur == end) {
         transport_parsing->deframe_state = GRPC_DTS_FH_1;
         return 1;
@@ -307,7 +307,7 @@ int grpc_chttp2_perform_read(grpc_exec_ctx *exec_ctx,
     /* fallthrough */
     case GRPC_DTS_FH_1:
       GPR_ASSERT(cur < end);
-      transport_parsing->incoming_frame_size |= ((gpr_uint32)*cur) << 8;
+      transport_parsing->incoming_frame_size |= ((uint32_t)*cur) << 8;
       if (++cur == end) {
         transport_parsing->deframe_state = GRPC_DTS_FH_2;
         return 1;
@@ -339,7 +339,7 @@ int grpc_chttp2_perform_read(grpc_exec_ctx *exec_ctx,
     /* fallthrough */
     case GRPC_DTS_FH_5:
       GPR_ASSERT(cur < end);
-      transport_parsing->incoming_stream_id = (((gpr_uint32)*cur) & 0x7f) << 24;
+      transport_parsing->incoming_stream_id = (((uint32_t)*cur) & 0x7f) << 24;
       if (++cur == end) {
         transport_parsing->deframe_state = GRPC_DTS_FH_6;
         return 1;
@@ -347,7 +347,7 @@ int grpc_chttp2_perform_read(grpc_exec_ctx *exec_ctx,
     /* fallthrough */
     case GRPC_DTS_FH_6:
       GPR_ASSERT(cur < end);
-      transport_parsing->incoming_stream_id |= ((gpr_uint32)*cur) << 16;
+      transport_parsing->incoming_stream_id |= ((uint32_t)*cur) << 16;
       if (++cur == end) {
         transport_parsing->deframe_state = GRPC_DTS_FH_7;
         return 1;
@@ -355,7 +355,7 @@ int grpc_chttp2_perform_read(grpc_exec_ctx *exec_ctx,
     /* fallthrough */
     case GRPC_DTS_FH_7:
       GPR_ASSERT(cur < end);
-      transport_parsing->incoming_stream_id |= ((gpr_uint32)*cur) << 8;
+      transport_parsing->incoming_stream_id |= ((uint32_t)*cur) << 8;
       if (++cur == end) {
         transport_parsing->deframe_state = GRPC_DTS_FH_8;
         return 1;
@@ -363,7 +363,7 @@ int grpc_chttp2_perform_read(grpc_exec_ctx *exec_ctx,
     /* fallthrough */
     case GRPC_DTS_FH_8:
       GPR_ASSERT(cur < end);
-      transport_parsing->incoming_stream_id |= ((gpr_uint32)*cur);
+      transport_parsing->incoming_stream_id |= ((uint32_t)*cur);
       transport_parsing->deframe_state = GRPC_DTS_FRAME;
       if (!init_frame_parser(exec_ctx, transport_parsing)) {
         return 0;
@@ -390,7 +390,7 @@ int grpc_chttp2_perform_read(grpc_exec_ctx *exec_ctx,
     /* fallthrough */
     case GRPC_DTS_FRAME:
       GPR_ASSERT(cur < end);
-      if ((gpr_uint32)(end - cur) == transport_parsing->incoming_frame_size) {
+      if ((uint32_t)(end - cur) == transport_parsing->incoming_frame_size) {
         if (!parse_frame_slice(exec_ctx, transport_parsing,
                                gpr_slice_sub_no_ref(slice, (size_t)(cur - beg),
                                                     (size_t)(end - beg)),
@@ -400,7 +400,7 @@ int grpc_chttp2_perform_read(grpc_exec_ctx *exec_ctx,
         transport_parsing->deframe_state = GRPC_DTS_FH_0;
         transport_parsing->incoming_stream = NULL;
         return 1;
-      } else if ((gpr_uint32)(end - cur) >
+      } else if ((uint32_t)(end - cur) >
                  transport_parsing->incoming_frame_size) {
         size_t cur_offset = (size_t)(cur - beg);
         if (!parse_frame_slice(
@@ -421,7 +421,7 @@ int grpc_chttp2_perform_read(grpc_exec_ctx *exec_ctx,
                                0)) {
           return 0;
         }
-        transport_parsing->incoming_frame_size -= (gpr_uint32)(end - cur);
+        transport_parsing->incoming_frame_size -= (uint32_t)(end - cur);
         return 1;
       }
       GPR_UNREACHABLE_CODE(return 0);
@@ -488,14 +488,14 @@ static int init_skip_frame_parser(
     grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_parsing *transport_parsing,
     int is_header) {
   if (is_header) {
-    gpr_uint8 is_eoh = transport_parsing->expect_continuation_stream_id != 0;
+    uint8_t is_eoh = transport_parsing->expect_continuation_stream_id != 0;
     transport_parsing->parser = grpc_chttp2_header_parser_parse;
     transport_parsing->parser_data = &transport_parsing->hpack_parser;
     transport_parsing->hpack_parser.on_header = skip_header;
     transport_parsing->hpack_parser.on_header_user_data = NULL;
     transport_parsing->hpack_parser.is_boundary = is_eoh;
     transport_parsing->hpack_parser.is_eof =
-        (gpr_uint8)(is_eoh ? transport_parsing->header_eof : 0);
+        (uint8_t)(is_eoh ? transport_parsing->header_eof : 0);
   } else {
     transport_parsing->parser = skip_parser;
   }
@@ -512,7 +512,7 @@ void grpc_chttp2_parsing_become_skip_parser(
 static grpc_chttp2_parse_error update_incoming_window(
     grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_parsing *transport_parsing,
     grpc_chttp2_stream_parsing *stream_parsing) {
-  gpr_uint32 incoming_frame_size = transport_parsing->incoming_frame_size;
+  uint32_t incoming_frame_size = transport_parsing->incoming_frame_size;
   if (incoming_frame_size > transport_parsing->incoming_window) {
     gpr_log(GPR_ERROR, "frame of size %d overflows incoming window of %d",
             transport_parsing->incoming_frame_size,
@@ -652,8 +652,8 @@ static void on_trailing_header(void *tp, grpc_mdelem *md) {
 static int init_header_frame_parser(
     grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_parsing *transport_parsing,
     int is_continuation) {
-  gpr_uint8 is_eoh = (transport_parsing->incoming_frame_flags &
-                      GRPC_CHTTP2_DATA_FLAG_END_HEADERS) != 0;
+  uint8_t is_eoh = (transport_parsing->incoming_frame_flags &
+                    GRPC_CHTTP2_DATA_FLAG_END_HEADERS) != 0;
   int via_accept = 0;
   grpc_chttp2_stream_parsing *stream_parsing;
 
@@ -738,7 +738,7 @@ static int init_header_frame_parser(
   transport_parsing->hpack_parser.on_header_user_data = transport_parsing;
   transport_parsing->hpack_parser.is_boundary = is_eoh;
   transport_parsing->hpack_parser.is_eof =
-      (gpr_uint8)(is_eoh ? transport_parsing->header_eof : 0);
+      (uint8_t)(is_eoh ? transport_parsing->header_eof : 0);
   if (!is_continuation && (transport_parsing->incoming_frame_flags &
                            GRPC_CHTTP2_FLAG_HAS_PRIORITY)) {
     grpc_chttp2_hpack_parser_set_has_priority(&transport_parsing->hpack_parser);
@@ -829,7 +829,7 @@ static int init_settings_frame_parser(
 }
 
 /*
-static int is_window_update_legal(gpr_int64 window_update, gpr_int64 window) {
+static int is_window_update_legal(int64_t window_update, int64_t window) {
   return window + window_update < MAX_WINDOW;
 }
 */

data/src/core/transport/chttp2/stream_lists.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
@@ -313,6 +313,35 @@ int grpc_chttp2_list_pop_check_read_ops(
   return r;
 }
 
+void grpc_chttp2_list_add_writing_stalled_by_transport(
+    grpc_chttp2_transport_writing *transport_writing,
+    grpc_chttp2_stream_writing *stream_writing) {
+  grpc_chttp2_stream *stream = STREAM_FROM_WRITING(stream_writing);
+  if (!stream->included[GRPC_CHTTP2_LIST_WRITING_STALLED_BY_TRANSPORT]) {
+    GRPC_CHTTP2_STREAM_REF(&stream->global, "chttp2_writing_stalled");
+  }
+  stream_list_add(TRANSPORT_FROM_WRITING(transport_writing), stream,
+                  GRPC_CHTTP2_LIST_WRITING_STALLED_BY_TRANSPORT);
+}
+
+void grpc_chttp2_list_flush_writing_stalled_by_transport(
+    grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_writing *transport_writing,
+    bool is_window_available) {
+  grpc_chttp2_stream *stream;
+  grpc_chttp2_transport *transport = TRANSPORT_FROM_WRITING(transport_writing);
+  while (stream_list_pop(transport, &stream,
+                         GRPC_CHTTP2_LIST_WRITING_STALLED_BY_TRANSPORT)) {
+    if (is_window_available) {
+      grpc_chttp2_list_add_writable_stream(&transport->global, &stream->global);
+    } else {
+      grpc_chttp2_list_add_stalled_by_transport(transport_writing,
+                                                &stream->writing);
+    }
+    GRPC_CHTTP2_STREAM_UNREF(exec_ctx, &stream->global,
+                             "chttp2_writing_stalled");
+  }
+}
+
 void grpc_chttp2_list_add_stalled_by_transport(
     grpc_chttp2_transport_writing *transport_writing,
     grpc_chttp2_stream_writing *stream_writing) {
@@ -333,6 +362,14 @@ int grpc_chttp2_list_pop_stalled_by_transport(
   return r;
 }
 
+void grpc_chttp2_list_remove_stalled_by_transport(
+    grpc_chttp2_transport_global *transport_global,
+    grpc_chttp2_stream_global *stream_global) {
+  stream_list_maybe_remove(TRANSPORT_FROM_GLOBAL(transport_global),
+                           STREAM_FROM_GLOBAL(stream_global),
+                           GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT);
+}
+
 void grpc_chttp2_list_add_closed_waiting_for_parsing(
     grpc_chttp2_transport_global *transport_global,
     grpc_chttp2_stream_global *stream_global) {

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

@@ -42,7 +42,7 @@
 void grpc_chttp2_stream_map_init(grpc_chttp2_stream_map *map,
                                  size_t initial_capacity) {
   GPR_ASSERT(initial_capacity > 1);
-  map->keys = gpr_malloc(sizeof(gpr_uint32) * initial_capacity);
+  map->keys = gpr_malloc(sizeof(uint32_t) * initial_capacity);
   map->values = gpr_malloc(sizeof(void *) * initial_capacity);
   map->count = 0;
   map->free = 0;
@@ -54,7 +54,7 @@ void grpc_chttp2_stream_map_destroy(grpc_chttp2_stream_map *map) {
   gpr_free(map->values);
 }
 
-static size_t compact(gpr_uint32 *keys, void **values, size_t count) {
+static size_t compact(uint32_t *keys, void **values, size_t count) {
   size_t i, out;
 
   for (i = 0, out = 0; i < count; i++) {
@@ -68,11 +68,11 @@ static size_t compact(gpr_uint32 *keys, void **values, size_t count) {
   return out;
 }
 
-void grpc_chttp2_stream_map_add(grpc_chttp2_stream_map *map, gpr_uint32 key,
+void grpc_chttp2_stream_map_add(grpc_chttp2_stream_map *map, uint32_t key,
                                 void *value) {
   size_t count = map->count;
   size_t capacity = map->capacity;
-  gpr_uint32 *keys = map->keys;
+  uint32_t *keys = map->keys;
   void **values = map->values;
 
   GPR_ASSERT(count == 0 || keys[count - 1] < key);
@@ -86,7 +86,7 @@ void grpc_chttp2_stream_map_add(grpc_chttp2_stream_map *map, gpr_uint32 key,
       /* resize when less than 25% of the table is free, because compaction
          won't help much */
       map->capacity = capacity = 3 * capacity / 2;
-      map->keys = keys = gpr_realloc(keys, capacity * sizeof(gpr_uint32));
+      map->keys = keys = gpr_realloc(keys, capacity * sizeof(uint32_t));
       map->values = values = gpr_realloc(values, capacity * sizeof(void *));
     }
   }
@@ -119,10 +119,10 @@ void grpc_chttp2_stream_map_move_into(grpc_chttp2_stream_map *src,
   /* if dst doesn't have capacity, resize */
   if (dst->count + src->count > dst->capacity) {
     dst->capacity = GPR_MAX(dst->capacity * 3 / 2, dst->count + src->count);
-    dst->keys = gpr_realloc(dst->keys, dst->capacity * sizeof(gpr_uint32));
+    dst->keys = gpr_realloc(dst->keys, dst->capacity * sizeof(uint32_t));
     dst->values = gpr_realloc(dst->values, dst->capacity * sizeof(void *));
   }
-  memcpy(dst->keys + dst->count, src->keys, src->count * sizeof(gpr_uint32));
+  memcpy(dst->keys + dst->count, src->keys, src->count * sizeof(uint32_t));
   memcpy(dst->values + dst->count, src->values, src->count * sizeof(void *));
   dst->count += src->count;
   dst->free += src->free;
@@ -130,13 +130,13 @@ void grpc_chttp2_stream_map_move_into(grpc_chttp2_stream_map *src,
   src->free = 0;
 }
 
-static void **find(grpc_chttp2_stream_map *map, gpr_uint32 key) {
+static void **find(grpc_chttp2_stream_map *map, uint32_t key) {
   size_t min_idx = 0;
   size_t max_idx = map->count;
   size_t mid_idx;
-  gpr_uint32 *keys = map->keys;
+  uint32_t *keys = map->keys;
   void **values = map->values;
-  gpr_uint32 mid_key;
+  uint32_t mid_key;
 
   if (max_idx == 0) return NULL;
 
@@ -158,8 +158,7 @@ static void **find(grpc_chttp2_stream_map *map, gpr_uint32 key) {
   return NULL;
 }
 
-void *grpc_chttp2_stream_map_delete(grpc_chttp2_stream_map *map,
-                                    gpr_uint32 key) {
+void *grpc_chttp2_stream_map_delete(grpc_chttp2_stream_map *map, uint32_t key) {
   void **pvalue = find(map, key);
   void *out = NULL;
   if (pvalue != NULL) {
@@ -175,7 +174,7 @@ void *grpc_chttp2_stream_map_delete(grpc_chttp2_stream_map *map,
   return out;
 }
 
-void *grpc_chttp2_stream_map_find(grpc_chttp2_stream_map *map, gpr_uint32 key) {
+void *grpc_chttp2_stream_map_find(grpc_chttp2_stream_map *map, uint32_t key) {
   void **pvalue = find(map, key);
   return pvalue != NULL ? *pvalue : NULL;
 }
@@ -185,7 +184,7 @@ size_t grpc_chttp2_stream_map_size(grpc_chttp2_stream_map *map) {
 }
 
 void grpc_chttp2_stream_map_for_each(grpc_chttp2_stream_map *map,
-                                     void (*f)(void *user_data, gpr_uint32 key,
+                                     void (*f)(void *user_data, uint32_t key,
                                                void *value),
                                      void *user_data) {
   size_t i;

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

@@ -38,14 +38,14 @@
 
 #include <stddef.h>
 
-/* Data structure to map a gpr_uint32 to a data object (represented by a void*)
+/* Data structure to map a uint32_t to a data object (represented by a void*)
 
    Represented as a sorted array of keys, and a corresponding array of values.
    Lookups are performed with binary search.
    Adds are restricted to strictly higher keys than previously seen (this is
    guaranteed by http2). */
 typedef struct {
-  gpr_uint32 *keys;
+  uint32_t *keys;
   void **values;
   size_t count;
   size_t free;
@@ -58,27 +58,26 @@ void grpc_chttp2_stream_map_destroy(grpc_chttp2_stream_map *map);
 
 /* Add a new key: given http2 semantics, new keys must always be greater than
    existing keys - this is asserted */
-void grpc_chttp2_stream_map_add(grpc_chttp2_stream_map *map, gpr_uint32 key,
+void grpc_chttp2_stream_map_add(grpc_chttp2_stream_map *map, uint32_t key,
                                 void *value);
 
 /* Delete an existing key - returns the previous value of the key if it existed,
    or NULL otherwise */
-void *grpc_chttp2_stream_map_delete(grpc_chttp2_stream_map *map,
-                                    gpr_uint32 key);
+void *grpc_chttp2_stream_map_delete(grpc_chttp2_stream_map *map, uint32_t key);
 
 /* Move all elements of src into dst */
 void grpc_chttp2_stream_map_move_into(grpc_chttp2_stream_map *src,
                                       grpc_chttp2_stream_map *dst);
 
 /* Return an existing key, or NULL if it does not exist */
-void *grpc_chttp2_stream_map_find(grpc_chttp2_stream_map *map, gpr_uint32 key);
+void *grpc_chttp2_stream_map_find(grpc_chttp2_stream_map *map, uint32_t key);
 
 /* How many (populated) entries are in the stream map? */
 size_t grpc_chttp2_stream_map_size(grpc_chttp2_stream_map *map);
 
 /* Callback on each stream */
 void grpc_chttp2_stream_map_for_each(grpc_chttp2_stream_map *map,
-                                     void (*f)(void *user_data, gpr_uint32 key,
+                                     void (*f)(void *user_data, uint32_t key,
                                                void *value),
                                      void *user_data);
 

data/src/core/transport/chttp2/timeout_encoding.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
@@ -39,12 +39,12 @@
 #include <grpc/support/port_platform.h>
 #include "src/core/support/string.h"
 
-static gpr_int64 round_up(gpr_int64 x, gpr_int64 divisor) {
+static int64_t round_up(int64_t x, int64_t divisor) {
   return (x / divisor + (x % divisor != 0)) * divisor;
 }
 
 /* round an integer up to the next value with three significant figures */
-static gpr_int64 round_up_to_three_sig_figs(gpr_int64 x) {
+static int64_t round_up_to_three_sig_figs(int64_t x) {
   if (x < 1000) return x;
   if (x < 10000) return round_up(x, 10);
   if (x < 100000) return round_up(x, 100);
@@ -58,13 +58,13 @@ static gpr_int64 round_up_to_three_sig_figs(gpr_int64 x) {
 /* encode our minimum viable timeout value */
 static void enc_tiny(char *buffer) { memcpy(buffer, "1n", 3); }
 
-static void enc_ext(char *buffer, gpr_int64 value, char ext) {
-  int n = gpr_int64toa(value, buffer);
+static void enc_ext(char *buffer, int64_t value, char ext) {
+  int n = int64_ttoa(value, buffer);
   buffer[n] = ext;
   buffer[n + 1] = 0;
 }
 
-static void enc_seconds(char *buffer, gpr_int64 sec) {
+static void enc_seconds(char *buffer, int64_t sec) {
   if (sec % 3600 == 0) {
     enc_ext(buffer, sec / 3600, 'H');
   } else if (sec % 60 == 0) {
@@ -74,7 +74,7 @@ static void enc_seconds(char *buffer, gpr_int64 sec) {
   }
 }
 
-static void enc_nanos(char *buffer, gpr_int64 x) {
+static void enc_nanos(char *buffer, int64_t x) {
   x = round_up_to_three_sig_figs(x);
   if (x < 100000) {
     if (x % 1000 == 0) {
@@ -98,7 +98,7 @@ static void enc_nanos(char *buffer, gpr_int64 x) {
   }
 }
 
-static void enc_micros(char *buffer, gpr_int64 x) {
+static void enc_micros(char *buffer, int64_t x) {
   x = round_up_to_three_sig_figs(x);
   if (x < 100000) {
     if (x % 1000 == 0) {
@@ -124,7 +124,7 @@ void grpc_chttp2_encode_timeout(gpr_timespec timeout, char *buffer) {
     enc_nanos(buffer, timeout.tv_nsec);
   } else if (timeout.tv_sec < 1000 && timeout.tv_nsec != 0) {
     enc_micros(buffer,
-               (gpr_int64)(timeout.tv_sec * 1000000) +
+               (int64_t)(timeout.tv_sec * 1000000) +
                    (timeout.tv_nsec / 1000 + (timeout.tv_nsec % 1000 != 0)));
   } else {
     enc_seconds(buffer, timeout.tv_sec + (timeout.tv_nsec != 0));
@@ -137,21 +137,24 @@ static int is_all_whitespace(const char *p) {
 }
 
 int grpc_chttp2_decode_timeout(const char *buffer, gpr_timespec *timeout) {
-  gpr_uint32 x = 0;
-  const gpr_uint8 *p = (const gpr_uint8 *)buffer;
+  int32_t x = 0;
+  const uint8_t *p = (const uint8_t *)buffer;
   int have_digit = 0;
   /* skip whitespace */
   for (; *p == ' '; p++)
     ;
   /* decode numeric part */
   for (; *p >= '0' && *p <= '9'; p++) {
-    gpr_uint32 xp = x * 10u + (gpr_uint32)*p - (gpr_uint32)'0';
+    int32_t digit = (int32_t)(*p - (uint8_t)'0');
     have_digit = 1;
-    if (xp < x) {
-      *timeout = gpr_inf_future(GPR_CLOCK_REALTIME);
-      return 1;
+    /* spec allows max. 8 digits, but we allow values up to 1,000,000,000 */
+    if (x >= (100 * 1000 * 1000)) {
+      if (x != (100 * 1000 * 1000) || digit != 0) {
+        *timeout = gpr_inf_future(GPR_CLOCK_REALTIME);
+        return 1;
+      }
     }
-    x = xp;
+    x = x * 10 + digit;
   }
   if (!have_digit) return 0;
   /* skip whitespace */