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

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

@@ -45,13 +45,13 @@
 typedef struct grpc_chttp2_hpack_parser grpc_chttp2_hpack_parser;
 
 typedef int (*grpc_chttp2_hpack_parser_state)(grpc_chttp2_hpack_parser *p,
-                                              const gpr_uint8 *beg,
-                                              const gpr_uint8 *end);
+                                              const uint8_t *beg,
+                                              const uint8_t *end);
 
 typedef struct {
   char *str;
-  gpr_uint32 length;
-  gpr_uint32 capacity;
+  uint32_t length;
+  uint32_t capacity;
 } grpc_chttp2_hpack_parser_string;
 
 struct grpc_chttp2_hpack_parser {
@@ -67,31 +67,31 @@ struct grpc_chttp2_hpack_parser {
   grpc_chttp2_hpack_parser_state after_prioritization;
   /* the value we're currently parsing */
   union {
-    gpr_uint32 *value;
+    uint32_t *value;
     grpc_chttp2_hpack_parser_string *str;
   } parsing;
   /* string parameters for each chunk */
   grpc_chttp2_hpack_parser_string key;
   grpc_chttp2_hpack_parser_string value;
   /* parsed index */
-  gpr_uint32 index;
+  uint32_t index;
   /* length of source bytes for the currently parsing string */
-  gpr_uint32 strlen;
+  uint32_t strlen;
   /* number of source bytes read for the currently parsing string */
-  gpr_uint32 strgot;
+  uint32_t strgot;
   /* huffman decoding state */
-  gpr_int16 huff_state;
+  int16_t huff_state;
   /* is the string being decoded binary? */
-  gpr_uint8 binary;
+  uint8_t binary;
   /* is the current string huffman encoded? */
-  gpr_uint8 huff;
+  uint8_t huff;
   /* is a dynamic table update allowed? */
-  gpr_uint8 dynamic_table_update_allowed;
+  uint8_t dynamic_table_update_allowed;
   /* set by higher layers, used by grpc_chttp2_header_parser_parse to signal
      it should append a metadata boundary at the end of frame */
-  gpr_uint8 is_boundary;
-  gpr_uint8 is_eof;
-  gpr_uint32 base64_buffer;
+  uint8_t is_boundary;
+  uint8_t is_eof;
+  uint32_t base64_buffer;
 
   /* hpack table */
   grpc_chttp2_hptbl table;
@@ -104,7 +104,7 @@ void grpc_chttp2_hpack_parser_set_has_priority(grpc_chttp2_hpack_parser *p);
 
 /* returns 1 on success, 0 on error */
 int grpc_chttp2_hpack_parser_parse(grpc_chttp2_hpack_parser *p,
-                                   const gpr_uint8 *beg, const gpr_uint8 *end);
+                                   const uint8_t *beg, const uint8_t *end);
 
 /* wraps grpc_chttp2_hpack_parser_parse to provide a frame level parser for
    the transport */

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

@@ -171,7 +171,7 @@ static struct {
     {"www-authenticate", ""},
 };
 
-static gpr_uint32 entries_for_bytes(gpr_uint32 bytes) {
+static uint32_t entries_for_bytes(uint32_t bytes) {
   return (bytes + GRPC_CHTTP2_HPACK_ENTRY_OVERHEAD - 1) /
          GRPC_CHTTP2_HPACK_ENTRY_OVERHEAD;
 }
@@ -204,7 +204,7 @@ void grpc_chttp2_hptbl_destroy(grpc_chttp2_hptbl *tbl) {
 }
 
 grpc_mdelem *grpc_chttp2_hptbl_lookup(const grpc_chttp2_hptbl *tbl,
-                                      gpr_uint32 tbl_index) {
+                                      uint32_t tbl_index) {
   /* Static table comes first, just return an entry from it */
   if (tbl_index <= GRPC_CHTTP2_LAST_STATIC_ENTRY) {
     return tbl->static_ents[tbl_index - 1];
@@ -212,7 +212,7 @@ grpc_mdelem *grpc_chttp2_hptbl_lookup(const grpc_chttp2_hptbl *tbl,
   /* Otherwise, find the value in the list of valid entries */
   tbl_index -= (GRPC_CHTTP2_LAST_STATIC_ENTRY + 1);
   if (tbl_index < tbl->num_ents) {
-    gpr_uint32 offset =
+    uint32_t offset =
         (tbl->num_ents - 1u - tbl_index + tbl->first_ent) % tbl->cap_entries;
     return tbl->ents[offset];
   }
@@ -227,15 +227,15 @@ static void evict1(grpc_chttp2_hptbl *tbl) {
                       GPR_SLICE_LENGTH(first_ent->value->slice) +
                       GRPC_CHTTP2_HPACK_ENTRY_OVERHEAD;
   GPR_ASSERT(elem_bytes <= tbl->mem_used);
-  tbl->mem_used -= (gpr_uint32)elem_bytes;
+  tbl->mem_used -= (uint32_t)elem_bytes;
   tbl->first_ent = ((tbl->first_ent + 1) % tbl->cap_entries);
   tbl->num_ents--;
   GRPC_MDELEM_UNREF(first_ent);
 }
 
-static void rebuild_ents(grpc_chttp2_hptbl *tbl, gpr_uint32 new_cap) {
+static void rebuild_ents(grpc_chttp2_hptbl *tbl, uint32_t new_cap) {
   grpc_mdelem **ents = gpr_malloc(sizeof(*ents) * new_cap);
-  gpr_uint32 i;
+  uint32_t i;
 
   for (i = 0; i < tbl->num_ents; i++) {
     ents[i] = tbl->ents[(tbl->first_ent + i) % tbl->cap_entries];
@@ -247,7 +247,7 @@ static void rebuild_ents(grpc_chttp2_hptbl *tbl, gpr_uint32 new_cap) {
 }
 
 void grpc_chttp2_hptbl_set_max_bytes(grpc_chttp2_hptbl *tbl,
-                                     gpr_uint32 max_bytes) {
+                                     uint32_t max_bytes) {
   if (tbl->max_bytes == max_bytes) {
     return;
   }
@@ -259,7 +259,7 @@ void grpc_chttp2_hptbl_set_max_bytes(grpc_chttp2_hptbl *tbl,
 }
 
 int grpc_chttp2_hptbl_set_current_table_size(grpc_chttp2_hptbl *tbl,
-                                             gpr_uint32 bytes) {
+                                             uint32_t bytes) {
   if (tbl->current_table_bytes == bytes) {
     return 1;
   }
@@ -278,7 +278,7 @@ int grpc_chttp2_hptbl_set_current_table_size(grpc_chttp2_hptbl *tbl,
   if (tbl->max_entries > tbl->cap_entries) {
     rebuild_ents(tbl, GPR_MAX(tbl->max_entries, 2 * tbl->cap_entries));
   } else if (tbl->max_entries < tbl->cap_entries / 3) {
-    gpr_uint32 new_cap = GPR_MAX(tbl->max_entries, 16u);
+    uint32_t new_cap = GPR_MAX(tbl->max_entries, 16u);
     if (new_cap != tbl->cap_entries) {
       rebuild_ents(tbl, new_cap);
     }
@@ -328,14 +328,14 @@ int grpc_chttp2_hptbl_add(grpc_chttp2_hptbl *tbl, grpc_mdelem *md) {
 
   /* update accounting values */
   tbl->num_ents++;
-  tbl->mem_used += (gpr_uint32)elem_bytes;
+  tbl->mem_used += (uint32_t)elem_bytes;
   return 1;
 }
 
 grpc_chttp2_hptbl_find_result grpc_chttp2_hptbl_find(
     const grpc_chttp2_hptbl *tbl, grpc_mdelem *md) {
   grpc_chttp2_hptbl_find_result r = {0, 0};
-  gpr_uint32 i;
+  uint32_t i;
 
   /* See if the string is in the static table */
   for (i = 0; i < GRPC_CHTTP2_LAST_STATIC_ENTRY; i++) {
@@ -348,8 +348,8 @@ grpc_chttp2_hptbl_find_result grpc_chttp2_hptbl_find(
 
   /* Scan the dynamic table */
   for (i = 0; i < tbl->num_ents; i++) {
-    gpr_uint32 idx =
-        (gpr_uint32)(tbl->num_ents - i + GRPC_CHTTP2_LAST_STATIC_ENTRY);
+    uint32_t idx =
+        (uint32_t)(tbl->num_ents - i + GRPC_CHTTP2_LAST_STATIC_ENTRY);
     grpc_mdelem *ent = tbl->ents[(tbl->first_ent + i) % tbl->cap_entries];
     if (md->key != ent->key) continue;
     r.index = idx;

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

@@ -60,21 +60,21 @@
 /* hpack decoder table */
 typedef struct {
   /* the first used entry in ents */
-  gpr_uint32 first_ent;
+  uint32_t first_ent;
   /* how many entries are in the table */
-  gpr_uint32 num_ents;
+  uint32_t num_ents;
   /* the amount of memory used by the table, according to the hpack algorithm */
-  gpr_uint32 mem_used;
+  uint32_t mem_used;
   /* the max memory allowed to be used by the table, according to the hpack
      algorithm */
-  gpr_uint32 max_bytes;
+  uint32_t max_bytes;
   /* the currently agreed size of the table, according to the hpack algorithm */
-  gpr_uint32 current_table_bytes;
+  uint32_t current_table_bytes;
   /* Maximum number of entries we could possibly fit in the table, given defined
      overheads */
-  gpr_uint32 max_entries;
+  uint32_t max_entries;
   /* Number of entries allocated in ents */
-  gpr_uint32 cap_entries;
+  uint32_t cap_entries;
   /* a circular buffer of headers - this is stored in the opposite order to
      what hpack specifies, in order to simplify table management a little...
      meaning lookups need to SUBTRACT from the end position */
@@ -86,20 +86,20 @@ typedef struct {
 void grpc_chttp2_hptbl_init(grpc_chttp2_hptbl *tbl);
 void grpc_chttp2_hptbl_destroy(grpc_chttp2_hptbl *tbl);
 void grpc_chttp2_hptbl_set_max_bytes(grpc_chttp2_hptbl *tbl,
-                                     gpr_uint32 max_bytes);
+                                     uint32_t max_bytes);
 int grpc_chttp2_hptbl_set_current_table_size(grpc_chttp2_hptbl *tbl,
-                                             gpr_uint32 bytes);
+                                             uint32_t bytes);
 
 /* lookup a table entry based on its hpack index */
 grpc_mdelem *grpc_chttp2_hptbl_lookup(const grpc_chttp2_hptbl *tbl,
-                                      gpr_uint32 index);
+                                      uint32_t index);
 /* add a table entry to the index */
 int grpc_chttp2_hptbl_add(grpc_chttp2_hptbl *tbl,
                           grpc_mdelem *md) GRPC_MUST_USE_RESULT;
 /* Find a key/value pair in the table... returns the index in the table of the
    most similar entry, or 0 if the value was not found */
 typedef struct {
-  gpr_uint32 index;
+  uint32_t index;
   int has_value;
 } grpc_chttp2_hptbl_find_result;
 grpc_chttp2_hptbl_find_result grpc_chttp2_hptbl_find(

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

@@ -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
@@ -35,6 +35,7 @@
 #define GRPC_INTERNAL_CORE_CHTTP2_INTERNAL_H
 
 #include <assert.h>
+#include <stdbool.h>
 
 #include "src/core/iomgr/endpoint.h"
 #include "src/core/transport/chttp2/frame.h"
@@ -67,6 +68,9 @@ typedef enum {
   GRPC_CHTTP2_LIST_CLOSED_WAITING_FOR_PARSING,
   GRPC_CHTTP2_LIST_CLOSED_WAITING_FOR_WRITING,
   GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT,
+  /* streams waiting for the outgoing window in the writing path, they will be
+   * merged to the stalled list or writable list under transport lock. */
+  GRPC_CHTTP2_LIST_WRITING_STALLED_BY_TRANSPORT,
   /** streams that are waiting to start because there are too many concurrent
       streams on the connection */
   GRPC_CHTTP2_LIST_WAITING_FOR_CONCURRENCY,
@@ -141,7 +145,7 @@ typedef enum {
 
 /* Outstanding ping request data */
 typedef struct grpc_chttp2_outstanding_ping {
-  gpr_uint8 id[8];
+  uint8_t id[8];
   grpc_closure *on_recv;
   struct grpc_chttp2_outstanding_ping *next;
   struct grpc_chttp2_outstanding_ping *prev;
@@ -152,6 +156,7 @@ struct grpc_chttp2_incoming_byte_stream {
   grpc_byte_stream base;
   gpr_refcount refs;
   struct grpc_chttp2_incoming_byte_stream *next_message;
+  int failed;
 
   grpc_chttp2_transport *transport;
   grpc_chttp2_stream *stream;
@@ -166,46 +171,46 @@ typedef struct {
   gpr_slice_buffer qbuf;
 
   /** window available for us to send to peer */
-  gpr_int64 outgoing_window;
+  int64_t outgoing_window;
   /** window available to announce to peer */
-  gpr_int64 announce_incoming_window;
+  int64_t announce_incoming_window;
   /** how much window would we like to have for incoming_window */
-  gpr_uint32 connection_window_target;
+  uint32_t connection_window_target;
 
   /** have we seen a goaway */
-  gpr_uint8 seen_goaway;
+  uint8_t seen_goaway;
   /** have we sent a goaway */
-  gpr_uint8 sent_goaway;
+  uint8_t sent_goaway;
 
   /** is this transport a client? */
-  gpr_uint8 is_client;
+  uint8_t is_client;
   /** are the local settings dirty and need to be sent? */
-  gpr_uint8 dirtied_local_settings;
+  uint8_t dirtied_local_settings;
   /** have local settings been sent? */
-  gpr_uint8 sent_local_settings;
+  uint8_t sent_local_settings;
   /** bitmask of setting indexes to send out */
-  gpr_uint32 force_send_settings;
+  uint32_t force_send_settings;
   /** settings values */
-  gpr_uint32 settings[GRPC_NUM_SETTING_SETS][GRPC_CHTTP2_NUM_SETTINGS];
+  uint32_t settings[GRPC_NUM_SETTING_SETS][GRPC_CHTTP2_NUM_SETTINGS];
 
   /** what is the next stream id to be allocated by this peer?
       copied to next_stream_id in parsing when parsing commences */
-  gpr_uint32 next_stream_id;
+  uint32_t next_stream_id;
 
   /** how far to lookahead in a stream? */
-  gpr_uint32 stream_lookahead;
+  uint32_t stream_lookahead;
 
   /** last received stream id */
-  gpr_uint32 last_incoming_stream_id;
+  uint32_t last_incoming_stream_id;
 
   /** pings awaiting responses */
   grpc_chttp2_outstanding_ping pings;
   /** next payload for an outgoing ping */
-  gpr_uint64 ping_counter;
+  uint64_t ping_counter;
 
   /** concurrent stream count: updated when not parsing,
       so this is a strict over-estimation on the client */
-  gpr_uint32 concurrent_stream_count;
+  uint32_t concurrent_stream_count;
 } grpc_chttp2_transport_global;
 
 typedef struct {
@@ -213,29 +218,29 @@ typedef struct {
   gpr_slice_buffer outbuf;
   /** hpack encoding */
   grpc_chttp2_hpack_compressor hpack_compressor;
-  gpr_int64 outgoing_window;
+  int64_t outgoing_window;
   /** is this a client? */
-  gpr_uint8 is_client;
+  uint8_t is_client;
   /** callback for when writing is done */
   grpc_closure done_cb;
 } grpc_chttp2_transport_writing;
 
 struct grpc_chttp2_transport_parsing {
   /** is this transport a client? (boolean) */
-  gpr_uint8 is_client;
+  uint8_t is_client;
 
   /** were settings updated? */
-  gpr_uint8 settings_updated;
+  uint8_t settings_updated;
   /** was a settings ack received? */
-  gpr_uint8 settings_ack_received;
+  uint8_t settings_ack_received;
   /** was a goaway frame received? */
-  gpr_uint8 goaway_received;
+  uint8_t goaway_received;
 
   /** the last sent max_table_size setting */
-  gpr_uint32 last_sent_max_table_size;
+  uint32_t last_sent_max_table_size;
 
   /** initial window change */
-  gpr_int64 initial_window_update;
+  int64_t initial_window_update;
 
   /** data to write later - after parsing */
   gpr_slice_buffer qbuf;
@@ -252,20 +257,20 @@ struct grpc_chttp2_transport_parsing {
   grpc_chttp2_goaway_parser goaway_parser;
 
   /** window available for peer to send to us */
-  gpr_int64 incoming_window;
+  int64_t incoming_window;
 
   /** next stream id available at the time of beginning parsing */
-  gpr_uint32 next_stream_id;
-  gpr_uint32 last_incoming_stream_id;
+  uint32_t next_stream_id;
+  uint32_t last_incoming_stream_id;
 
   /* deframing */
   grpc_chttp2_deframe_transport_state deframe_state;
-  gpr_uint8 incoming_frame_type;
-  gpr_uint8 incoming_frame_flags;
-  gpr_uint8 header_eof;
-  gpr_uint32 expect_continuation_stream_id;
-  gpr_uint32 incoming_frame_size;
-  gpr_uint32 incoming_stream_id;
+  uint8_t incoming_frame_type;
+  uint8_t incoming_frame_flags;
+  uint8_t header_eof;
+  uint32_t expect_continuation_stream_id;
+  uint32_t incoming_frame_size;
+  uint32_t incoming_stream_id;
 
   /* active parser */
   void *parser_data;
@@ -276,14 +281,14 @@ struct grpc_chttp2_transport_parsing {
       grpc_chttp2_stream_parsing *stream_parsing, gpr_slice slice, int is_last);
 
   /* received settings */
-  gpr_uint32 settings[GRPC_CHTTP2_NUM_SETTINGS];
+  uint32_t settings[GRPC_CHTTP2_NUM_SETTINGS];
 
   /* goaway data */
   grpc_status_code goaway_error;
-  gpr_uint32 goaway_last_stream_index;
+  uint32_t goaway_last_stream_index;
   gpr_slice goaway_text;
 
-  gpr_int64 outgoing_window;
+  int64_t outgoing_window;
 };
 
 struct grpc_chttp2_transport {
@@ -298,17 +303,17 @@ struct grpc_chttp2_transport {
   gpr_mu mu;
 
   /** is the transport destroying itself? */
-  gpr_uint8 destroying;
+  uint8_t destroying;
   /** has the upper layer closed the transport? */
-  gpr_uint8 closed;
+  uint8_t closed;
 
   /** is a thread currently writing */
-  gpr_uint8 writing_active;
+  uint8_t writing_active;
   /** is a thread currently parsing */
-  gpr_uint8 parsing_active;
+  uint8_t parsing_active;
 
   /** is there a read request to the endpoint outstanding? */
-  gpr_uint8 endpoint_reading;
+  uint8_t endpoint_reading;
 
   /** various lists of streams */
   grpc_chttp2_stream_list lists[STREAM_LIST_COUNT];
@@ -357,20 +362,20 @@ struct grpc_chttp2_transport {
 
 typedef struct {
   /** HTTP2 stream id for this stream, or zero if one has not been assigned */
-  gpr_uint32 id;
+  uint32_t id;
 
   /** window available for us to send to peer */
-  gpr_int64 outgoing_window;
+  int64_t outgoing_window;
   /** The number of bytes the upper layers have offered to receive.
       As the upper layer offers more bytes, this value increases.
       As bytes are read, this value decreases. */
-  gpr_uint32 max_recv_bytes;
+  uint32_t max_recv_bytes;
   /** The number of bytes the upper layer has offered to read but we have
       not yet announced to HTTP2 flow control.
       As the upper layers offer to read more bytes, this value increases.
       As we advertise incoming flow control window, this value decreases. */
-  gpr_uint32 unannounced_incoming_window_for_parse;
-  gpr_uint32 unannounced_incoming_window_for_writing;
+  uint32_t unannounced_incoming_window_for_parse;
+  uint32_t unannounced_incoming_window_for_writing;
   /** things the upper layers would like to send */
   grpc_metadata_batch *send_initial_metadata;
   grpc_closure *send_initial_metadata_finished;
@@ -380,7 +385,7 @@ typedef struct {
   grpc_closure *send_trailing_metadata_finished;
 
   grpc_metadata_batch *recv_initial_metadata;
-  grpc_closure *recv_initial_metadata_finished;
+  grpc_closure *recv_initial_metadata_ready;
   grpc_byte_stream **recv_message;
   grpc_closure *recv_message_ready;
   grpc_metadata_batch *recv_trailing_metadata;
@@ -389,18 +394,18 @@ typedef struct {
   /** when the application requests writes be closed, the write_closed is
       'queued'; when the close is flow controlled into the send path, we are
       'sending' it; when the write has been performed it is 'sent' */
-  gpr_uint8 write_closed;
+  uint8_t write_closed;
   /** is this stream reading half-closed (boolean) */
-  gpr_uint8 read_closed;
+  uint8_t read_closed;
   /** is this stream in the stream map? (boolean) */
-  gpr_uint8 in_stream_map;
+  uint8_t in_stream_map;
   /** has this stream seen an error? if 1, then pending incoming frames
       can be thrown away */
-  gpr_uint8 seen_error;
+  uint8_t seen_error;
 
-  gpr_uint8 published_initial_metadata;
-  gpr_uint8 published_trailing_metadata;
-  gpr_uint8 faked_trailing_metadata;
+  uint8_t published_initial_metadata;
+  uint8_t published_trailing_metadata;
+  uint8_t faked_trailing_metadata;
 
   grpc_chttp2_incoming_metadata_buffer received_initial_metadata;
   grpc_chttp2_incoming_metadata_buffer received_trailing_metadata;
@@ -410,19 +415,19 @@ typedef struct {
 
 typedef struct {
   /** HTTP2 stream id for this stream, or zero if one has not been assigned */
-  gpr_uint32 id;
-  gpr_uint8 fetching;
-  gpr_uint8 sent_initial_metadata;
-  gpr_uint8 sent_message;
-  gpr_uint8 sent_trailing_metadata;
-  gpr_uint8 read_closed;
+  uint32_t id;
+  uint8_t fetching;
+  uint8_t sent_initial_metadata;
+  uint8_t sent_message;
+  uint8_t sent_trailing_metadata;
+  uint8_t read_closed;
   /** send this initial metadata */
   grpc_metadata_batch *send_initial_metadata;
   grpc_byte_stream *send_message;
   grpc_metadata_batch *send_trailing_metadata;
-  gpr_int64 outgoing_window;
+  int64_t outgoing_window;
   /** how much window should we announce? */
-  gpr_uint32 announce_window;
+  uint32_t announce_window;
   gpr_slice_buffer flow_controlled_buffer;
   gpr_slice fetching_slice;
   size_t stream_fetched;
@@ -431,27 +436,27 @@ typedef struct {
 
 struct grpc_chttp2_stream_parsing {
   /** HTTP2 stream id for this stream, or zero if one has not been assigned */
-  gpr_uint32 id;
+  uint32_t id;
   /** has this stream received a close */
-  gpr_uint8 received_close;
+  uint8_t received_close;
   /** saw a rst_stream */
-  gpr_uint8 saw_rst_stream;
+  uint8_t saw_rst_stream;
   /** how many header frames have we received? */
-  gpr_uint8 header_frames_received;
+  uint8_t header_frames_received;
   /** which metadata did we get (on this parse) */
-  gpr_uint8 got_metadata_on_parse[2];
+  uint8_t got_metadata_on_parse[2];
   /** should we raise the seen_error flag in transport_global */
-  gpr_uint8 seen_error;
+  uint8_t seen_error;
   /** window available for peer to send to us */
-  gpr_int64 incoming_window;
+  int64_t incoming_window;
   /** parsing state for data frames */
   grpc_chttp2_data_parser data_parser;
   /** reason give to rst_stream */
-  gpr_uint32 rst_stream_reason;
+  uint32_t rst_stream_reason;
   /** amount of window given */
-  gpr_int64 outgoing_window;
+  int64_t outgoing_window;
   /** number of bytes received - reset at end of parse thread execution */
-  gpr_int64 received_bytes;
+  int64_t received_bytes;
 
   /** incoming metadata */
   grpc_chttp2_incoming_metadata_buffer metadata_buffer[2];
@@ -464,7 +469,7 @@ struct grpc_chttp2_stream {
   grpc_chttp2_stream_parsing parsing;
 
   grpc_chttp2_stream_link links[STREAM_LIST_COUNT];
-  gpr_uint8 included[STREAM_LIST_COUNT];
+  uint8_t included[STREAM_LIST_COUNT];
 };
 
 /** Transport writing call flow:
@@ -480,14 +485,15 @@ struct grpc_chttp2_stream {
 
 /** Someone is unlocking the transport mutex: check to see if writes
     are required, and schedule them if so */
-int grpc_chttp2_unlocking_check_writes(grpc_chttp2_transport_global *global,
+int grpc_chttp2_unlocking_check_writes(grpc_exec_ctx *exec_ctx,
+                                       grpc_chttp2_transport_global *global,
                                        grpc_chttp2_transport_writing *writing,
                                        int is_parsing);
 void grpc_chttp2_perform_writes(
     grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_writing *transport_writing,
     grpc_endpoint *endpoint);
 void grpc_chttp2_terminate_writing(grpc_exec_ctx *exec_ctx,
-                                   void *transport_writing, int success);
+                                   void *transport_writing, bool success);
 void grpc_chttp2_cleanup_writing(grpc_exec_ctx *exec_ctx,
                                  grpc_chttp2_transport_global *global,
                                  grpc_chttp2_transport_writing *writing);
@@ -503,11 +509,11 @@ void grpc_chttp2_publish_reads(grpc_exec_ctx *exec_ctx,
                                grpc_chttp2_transport_global *global,
                                grpc_chttp2_transport_parsing *parsing);
 
-/** Get a writable stream
-    returns non-zero if there was a stream available */
 void grpc_chttp2_list_add_writable_stream(
     grpc_chttp2_transport_global *transport_global,
     grpc_chttp2_stream_global *stream_global);
+/** Get a writable stream
+    returns non-zero if there was a stream available */
 int grpc_chttp2_list_pop_writable_stream(
     grpc_chttp2_transport_global *transport_global,
     grpc_chttp2_transport_writing *transport_writing,
@@ -559,12 +565,22 @@ int grpc_chttp2_list_pop_check_read_ops(
     grpc_chttp2_transport_global *transport_global,
     grpc_chttp2_stream_global **stream_global);
 
+void grpc_chttp2_list_add_writing_stalled_by_transport(
+    grpc_chttp2_transport_writing *transport_writing,
+    grpc_chttp2_stream_writing *stream_writing);
+void grpc_chttp2_list_flush_writing_stalled_by_transport(
+    grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_writing *transport_writing,
+    bool is_window_available);
+
 void grpc_chttp2_list_add_stalled_by_transport(
     grpc_chttp2_transport_writing *transport_writing,
     grpc_chttp2_stream_writing *stream_writing);
 int grpc_chttp2_list_pop_stalled_by_transport(
     grpc_chttp2_transport_global *transport_global,
     grpc_chttp2_stream_global **stream_global);
+void grpc_chttp2_list_remove_stalled_by_transport(
+    grpc_chttp2_transport_global *transport_global,
+    grpc_chttp2_stream_global *stream_global);
 
 void grpc_chttp2_list_add_unannounced_incoming_window_available(
     grpc_chttp2_transport_global *transport_global,
@@ -593,14 +609,14 @@ int grpc_chttp2_list_pop_closed_waiting_for_writing(
     grpc_chttp2_stream_global **stream_global);
 
 grpc_chttp2_stream_parsing *grpc_chttp2_parsing_lookup_stream(
-    grpc_chttp2_transport_parsing *transport_parsing, gpr_uint32 id);
+    grpc_chttp2_transport_parsing *transport_parsing, uint32_t id);
 grpc_chttp2_stream_parsing *grpc_chttp2_parsing_accept_stream(
     grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_parsing *transport_parsing,
-    gpr_uint32 id);
+    uint32_t id);
 
 void grpc_chttp2_add_incoming_goaway(
     grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_global *transport_global,
-    gpr_uint32 goaway_error, gpr_slice goaway_text);
+    uint32_t goaway_error, gpr_slice goaway_text);
 
 void grpc_chttp2_register_stream(grpc_chttp2_transport *t,
                                  grpc_chttp2_stream *s);
@@ -706,8 +722,7 @@ void grpc_chttp2_flowctl_trace(const char *file, int line, const char *phase,
                                grpc_chttp2_flowctl_op op, const char *context1,
                                const char *var1, const char *context2,
                                const char *var2, int is_client,
-                               gpr_uint32 stream_id, gpr_int64 val1,
-                               gpr_int64 val2);
+                               uint32_t stream_id, int64_t val1, int64_t val2);
 
 void grpc_chttp2_fake_status(grpc_exec_ctx *exec_ctx,
                              grpc_chttp2_transport_global *transport_global,
@@ -742,16 +757,17 @@ void grpc_chttp2_stream_unref(grpc_exec_ctx *exec_ctx,
 
 grpc_chttp2_incoming_byte_stream *grpc_chttp2_incoming_byte_stream_create(
     grpc_exec_ctx *exec_ctx, grpc_chttp2_transport_parsing *transport_parsing,
-    grpc_chttp2_stream_parsing *stream_parsing, gpr_uint32 frame_size,
-    gpr_uint32 flags, grpc_chttp2_incoming_frame_queue *add_to_queue);
+    grpc_chttp2_stream_parsing *stream_parsing, uint32_t frame_size,
+    uint32_t flags, grpc_chttp2_incoming_frame_queue *add_to_queue);
 void grpc_chttp2_incoming_byte_stream_push(grpc_exec_ctx *exec_ctx,
                                            grpc_chttp2_incoming_byte_stream *bs,
                                            gpr_slice slice);
 void grpc_chttp2_incoming_byte_stream_finished(
-    grpc_exec_ctx *exec_ctx, grpc_chttp2_incoming_byte_stream *bs);
+    grpc_exec_ctx *exec_ctx, grpc_chttp2_incoming_byte_stream *bs, int success,
+    int from_parsing_thread);
 
 void grpc_chttp2_ack_ping(grpc_exec_ctx *exec_ctx,
                           grpc_chttp2_transport_parsing *parsing,
-                          const gpr_uint8 *opaque_8bytes);
+                          const uint8_t *opaque_8bytes);
 
 #endif