grpc 1.37.1 → 1.40.0.pre1

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

@@ -27,91 +27,212 @@
 #include "src/core/ext/transport/chttp2/transport/hpack_table.h"
 #include "src/core/lib/transport/metadata.h"
 
-typedef struct grpc_chttp2_hpack_parser grpc_chttp2_hpack_parser;
+namespace grpc_core {
 
-typedef grpc_error* (*grpc_chttp2_hpack_parser_state)(
-    grpc_chttp2_hpack_parser* p, const uint8_t* beg, const uint8_t* end);
+class HPackParser {
+ public:
+  enum class Boundary { None, EndOfHeaders, EndOfStream };
+  enum class Priority { None, Included };
 
-struct grpc_chttp2_hpack_parser_string {
-  bool copied;
-  struct {
-    grpc_slice referenced;
+  // User specified structure called for each received header.
+  using Sink = std::function<grpc_error_handle(grpc_mdelem)>;
+
+  HPackParser();
+  ~HPackParser();
+
+  HPackParser(const HPackParser&) = delete;
+  HPackParser& operator=(const HPackParser&) = delete;
+
+  void BeginFrame(Sink sink, Boundary boundary, Priority priority);
+  void ResetSink(Sink sink) { sink_ = std::move(sink); }
+  grpc_error_handle Parse(const grpc_slice& slice);
+  void FinishFrame();
+
+  grpc_chttp2_hptbl* hpack_table() { return &table_; }
+  bool is_boundary() const { return boundary_ != Boundary::None; }
+  bool is_eof() const { return boundary_ == Boundary::EndOfStream; }
+  bool is_in_begin_state() const { return state_ == &HPackParser::parse_begin; }
+
+ private:
+  enum class BinaryState {
+    kNotBinary,
+    kBinaryBegin,
+    kBase64Byte0,
+    kBase64Byte1,
+    kBase64Byte2,
+    kBase64Byte3,
+  };
+
+  struct String {
+    bool copied_;
     struct {
-      char* str;
-      uint32_t length;
-      uint32_t capacity;
-    } copied;
-  } data;
-};
-struct grpc_chttp2_hpack_parser {
-  /* user specified callback for each header output */
-  grpc_error* (*on_header)(void* user_data, grpc_mdelem md);
-  void* on_header_user_data;
-
-  grpc_error* last_error;
-
-  /* current parse state - or a function that implements it */
-  grpc_chttp2_hpack_parser_state state;
-  /* future states dependent on the opening op code */
-  const grpc_chttp2_hpack_parser_state* next_state;
-  /* what to do after skipping prioritization data */
-  grpc_chttp2_hpack_parser_state after_prioritization;
-  /* the refcount of the slice that we're currently parsing */
-  grpc_slice_refcount* current_slice_refcount;
-  /* the value we're currently parsing */
+      grpc_slice referenced;
+      struct {
+        char* str;
+        uint32_t length;
+        uint32_t capacity;
+      } copied;
+    } data_;
+
+    UnmanagedMemorySlice TakeExtern();
+    ManagedMemorySlice TakeIntern();
+    void AppendBytes(const uint8_t* data, size_t length);
+  };
+
+  using State = grpc_error_handle (HPackParser::*)(const uint8_t* beg,
+                                                   const uint8_t* end);
+
+  // Forward declarations for parsing states.
+  // These are keeping their old (C-style) names until a future refactor where
+  // they will be eliminated.
+  grpc_error_handle parse_next(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_begin(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_error(const uint8_t* cur, const uint8_t* end,
+                                grpc_error_handle error);
+  grpc_error_handle still_parse_error(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_illegal_op(const uint8_t* cur, const uint8_t* end);
+
+  grpc_error_handle parse_string_prefix(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_key_string(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_value_string(const uint8_t* cur, const uint8_t* end,
+                                       bool is_binary);
+  grpc_error_handle parse_value_string_with_indexed_key(const uint8_t* cur,
+                                                        const uint8_t* end);
+  grpc_error_handle parse_value_string_with_literal_key(const uint8_t* cur,
+                                                        const uint8_t* end);
+  grpc_error_handle parse_stream_weight(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_value0(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_value1(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_value2(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_value3(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_value4(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_value5up(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_stream_dep0(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_stream_dep1(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_stream_dep2(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_stream_dep3(const uint8_t* cur, const uint8_t* end);
+
+  grpc_error_handle parse_indexed_field(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_indexed_field_x(const uint8_t* cur,
+                                          const uint8_t* end);
+  grpc_error_handle parse_lithdr_incidx(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_lithdr_incidx_x(const uint8_t* cur,
+                                          const uint8_t* end);
+  grpc_error_handle parse_lithdr_incidx_v(const uint8_t* cur,
+                                          const uint8_t* end);
+  grpc_error_handle parse_lithdr_notidx(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_lithdr_notidx_x(const uint8_t* cur,
+                                          const uint8_t* end);
+  grpc_error_handle parse_lithdr_notidx_v(const uint8_t* cur,
+                                          const uint8_t* end);
+  grpc_error_handle parse_lithdr_nvridx(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_lithdr_nvridx_x(const uint8_t* cur,
+                                          const uint8_t* end);
+  grpc_error_handle parse_lithdr_nvridx_v(const uint8_t* cur,
+                                          const uint8_t* end);
+  grpc_error_handle parse_max_tbl_size(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_max_tbl_size_x(const uint8_t* cur,
+                                         const uint8_t* end);
+  grpc_error_handle parse_string(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle begin_parse_string(const uint8_t* cur, const uint8_t* end,
+                                       BinaryState binary, String* str);
+
+  grpc_error_handle finish_indexed_field(const uint8_t* cur,
+                                         const uint8_t* end);
+  grpc_error_handle finish_lithdr_incidx(const uint8_t* cur,
+                                         const uint8_t* end);
+  grpc_error_handle finish_lithdr_incidx_v(const uint8_t* cur,
+                                           const uint8_t* end);
+  grpc_error_handle finish_lithdr_notidx(const uint8_t* cur,
+                                         const uint8_t* end);
+  grpc_error_handle finish_lithdr_notidx_v(const uint8_t* cur,
+                                           const uint8_t* end);
+  grpc_error_handle finish_lithdr_nvridx(const uint8_t* cur,
+                                         const uint8_t* end);
+  grpc_error_handle finish_lithdr_nvridx_v(const uint8_t* cur,
+                                           const uint8_t* end);
+  grpc_error_handle finish_max_tbl_size(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle finish_str(const uint8_t* cur, const uint8_t* end);
+
+  enum class TableAction {
+    kAddToTable,
+    kOmitFromTable,
+  };
+
+  GPR_ATTRIBUTE_NOINLINE grpc_error_handle InvalidHPackIndexError();
+  GPR_ATTRIBUTE_NOINLINE void LogHeader(grpc_mdelem md);
+  grpc_error_handle AddHeaderToTable(grpc_mdelem md);
+  template <TableAction table_action>
+  grpc_error_handle FinishHeader(grpc_mdelem md);
+
+  grpc_mdelem GetPrecomputedMDForIndex();
+  void SetPrecomputedMDIndex(grpc_mdelem md);
+  bool IsBinaryLiteralHeader();
+  grpc_error_handle IsBinaryIndexedHeader(bool* is);
+
+  grpc_error_handle AppendString(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle AppendHuffNibble(uint8_t nibble);
+  grpc_error_handle AppendHuffBytes(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle AppendStrBytes(const uint8_t* cur, const uint8_t* end);
+
+  Sink sink_;
+  grpc_error_handle last_error_;
+
+  // current parse state - or a function that implements it
+  State state_;
+  // future states dependent on the opening op code
+  const State* next_state_;
+  // what to do after skipping prioritization data
+  State after_prioritization_;
+  // the refcount of the slice that we're currently parsing
+  grpc_slice_refcount* current_slice_refcount_;
+  // the value we're currently parsing
   union {
     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 */
-  uint32_t index;
-  /* When we parse a value string, we determine the metadata element for a
-     specific index, which we need again when we're finishing up with that
-     header. To avoid calculating the metadata element for that index a second
-     time at that stage, we cache (and invalidate) the element here. */
-  grpc_mdelem md_for_index;
+    String* str;
+  } parsing_;
+  // string parameters for each chunk
+  String key_;
+  String value_;
+  // parsed index
+  uint32_t index_;
+  // When we parse a value string, we determine the metadata element for a
+  // specific index, which we need again when we're finishing up with that
+  // header. To avoid calculating the metadata element for that index a second
+  // time at that stage, we cache (and invalidate) the element here.
+  grpc_mdelem md_for_index_;
 #ifndef NDEBUG
-  int64_t precomputed_md_index;
+  int64_t precomputed_md_index_;
 #endif
-  /* length of source bytes for the currently parsing string */
-  uint32_t strlen;
-  /* number of source bytes read for the currently parsing string */
-  uint32_t strgot;
-  /* huffman decoding state */
-  int16_t huff_state;
-  /* is the string being decoded binary? */
-  uint8_t binary;
-  /* is the current string huffman encoded? */
-  uint8_t huff;
-  /* is a 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 */
-  uint8_t is_boundary;
-  uint8_t is_eof;
-  uint32_t base64_buffer;
-
-  /* hpack table */
-  grpc_chttp2_hptbl table;
-};
+  // length of source bytes for the currently parsing string
+  uint32_t strlen_;
+  // number of source bytes read for the currently parsing string
+  uint32_t strgot_;
+  // huffman decoding state
+  int16_t huff_state_;
+  // is the string being decoded binary?
+  BinaryState binary_;
+  // is the current string huffman encoded?
+  bool huff_;
+  // is a dynamic table update allowed?
+  uint8_t dynamic_table_updates_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
+  Boundary boundary_;
+  uint32_t base64_buffer_;
 
-void grpc_chttp2_hpack_parser_init(grpc_chttp2_hpack_parser* p);
-void grpc_chttp2_hpack_parser_destroy(grpc_chttp2_hpack_parser* p);
-
-void grpc_chttp2_hpack_parser_set_has_priority(grpc_chttp2_hpack_parser* p);
+  // hpack table
+  grpc_chttp2_hptbl table_;
+};
 
-grpc_error* grpc_chttp2_hpack_parser_parse(grpc_chttp2_hpack_parser* p,
-                                           const grpc_slice& slice);
+}  // namespace grpc_core
 
 /* wraps grpc_chttp2_hpack_parser_parse to provide a frame level parser for
    the transport */
-grpc_error* grpc_chttp2_header_parser_parse(void* hpack_parser,
-                                            grpc_chttp2_transport* t,
-                                            grpc_chttp2_stream* s,
-                                            const grpc_slice& slice,
-                                            int is_last);
+grpc_error_handle grpc_chttp2_header_parser_parse(void* hpack_parser,
+                                                  grpc_chttp2_transport* t,
+                                                  grpc_chttp2_stream* s,
+                                                  const grpc_slice& slice,
+                                                  int is_last);
 
 #endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_H */

data/src/core/ext/transport/chttp2/transport/hpack_table.cc

@@ -114,8 +114,8 @@ void grpc_chttp2_hptbl_set_max_bytes(grpc_chttp2_hptbl* tbl,
   tbl->max_bytes = max_bytes;
 }
 
-grpc_error* grpc_chttp2_hptbl_set_current_table_size(grpc_chttp2_hptbl* tbl,
-                                                     uint32_t bytes) {
+grpc_error_handle grpc_chttp2_hptbl_set_current_table_size(
+    grpc_chttp2_hptbl* tbl, uint32_t bytes) {
   if (tbl->current_table_bytes == bytes) {
     return GRPC_ERROR_NONE;
   }
@@ -145,7 +145,8 @@ grpc_error* grpc_chttp2_hptbl_set_current_table_size(grpc_chttp2_hptbl* tbl,
   return GRPC_ERROR_NONE;
 }
 
-grpc_error* grpc_chttp2_hptbl_add(grpc_chttp2_hptbl* tbl, grpc_mdelem md) {
+grpc_error_handle grpc_chttp2_hptbl_add(grpc_chttp2_hptbl* tbl,
+                                        grpc_mdelem md) {
   /* determine how many bytes of buffer this entry represents */
   size_t elem_bytes = GRPC_SLICE_LENGTH(GRPC_MDKEY(md)) +
                       GRPC_SLICE_LENGTH(GRPC_MDVALUE(md)) +

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

@@ -89,8 +89,8 @@ struct grpc_chttp2_hptbl {
 void grpc_chttp2_hptbl_destroy(grpc_chttp2_hptbl* tbl);
 void grpc_chttp2_hptbl_set_max_bytes(grpc_chttp2_hptbl* tbl,
                                      uint32_t max_bytes);
-grpc_error* grpc_chttp2_hptbl_set_current_table_size(grpc_chttp2_hptbl* tbl,
-                                                     uint32_t bytes);
+grpc_error_handle grpc_chttp2_hptbl_set_current_table_size(
+    grpc_chttp2_hptbl* tbl, uint32_t bytes);
 
 /* lookup a table entry based on its hpack index */
 grpc_mdelem grpc_chttp2_hptbl_lookup_dynamic_index(const grpc_chttp2_hptbl* tbl,
@@ -117,8 +117,8 @@ inline grpc_mdelem grpc_chttp2_hptbl_lookup(const grpc_chttp2_hptbl* tbl,
   }
 }
 /* add a table entry to the index */
-grpc_error* grpc_chttp2_hptbl_add(grpc_chttp2_hptbl* tbl,
-                                  grpc_mdelem md) GRPC_MUST_USE_RESULT;
+grpc_error_handle grpc_chttp2_hptbl_add(grpc_chttp2_hptbl* tbl,
+                                        grpc_mdelem md) GRPC_MUST_USE_RESULT;
 
 size_t grpc_chttp2_get_size_in_hpack_table(grpc_mdelem elem,
                                            bool use_true_binary_metadata);

data/src/core/ext/transport/chttp2/transport/incoming_metadata.cc

@@ -27,7 +27,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-grpc_error* grpc_chttp2_incoming_metadata_buffer_add(
+grpc_error_handle grpc_chttp2_incoming_metadata_buffer_add(
     grpc_chttp2_incoming_metadata_buffer* buffer, grpc_mdelem elem) {
   buffer->size += GRPC_MDELEM_LENGTH(elem);
   grpc_linked_mdelem* storage;
@@ -42,7 +42,7 @@ grpc_error* grpc_chttp2_incoming_metadata_buffer_add(
   return grpc_metadata_batch_link_tail(&buffer->batch, storage);
 }
 
-grpc_error* grpc_chttp2_incoming_metadata_buffer_replace_or_add(
+grpc_error_handle grpc_chttp2_incoming_metadata_buffer_replace_or_add(
     grpc_chttp2_incoming_metadata_buffer* buffer, grpc_mdelem elem) {
   for (grpc_linked_mdelem* l = buffer->batch.list.head; l != nullptr;
        l = l->next) {

data/src/core/ext/transport/chttp2/transport/incoming_metadata.h

@@ -46,10 +46,10 @@ struct grpc_chttp2_incoming_metadata_buffer {
 void grpc_chttp2_incoming_metadata_buffer_publish(
     grpc_chttp2_incoming_metadata_buffer* buffer, grpc_metadata_batch* batch);
 
-grpc_error* grpc_chttp2_incoming_metadata_buffer_add(
+grpc_error_handle grpc_chttp2_incoming_metadata_buffer_add(
     grpc_chttp2_incoming_metadata_buffer* buffer,
     grpc_mdelem elem) GRPC_MUST_USE_RESULT;
-grpc_error* grpc_chttp2_incoming_metadata_buffer_replace_or_add(
+grpc_error_handle grpc_chttp2_incoming_metadata_buffer_replace_or_add(
     grpc_chttp2_incoming_metadata_buffer* buffer,
     grpc_mdelem elem) GRPC_MUST_USE_RESULT;
 void grpc_chttp2_incoming_metadata_buffer_set_deadline(

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

@@ -217,8 +217,8 @@ class Chttp2IncomingByteStream : public ByteStream {
   void Orphan() override;
 
   bool Next(size_t max_size_hint, grpc_closure* on_complete) override;
-  grpc_error* Pull(grpc_slice* slice) override;
-  void Shutdown(grpc_error* error) override;
+  grpc_error_handle Pull(grpc_slice* slice) override;
+  void Shutdown(grpc_error_handle error) override;
 
   // TODO(roth): When I converted this class to C++, I wanted to make it
   // inherit from RefCounted or InternallyRefCounted instead of continuing
@@ -241,17 +241,17 @@ class Chttp2IncomingByteStream : public ByteStream {
     }
   }
 
-  void PublishError(grpc_error* error);
+  void PublishError(grpc_error_handle error);
 
-  grpc_error* Push(const grpc_slice& slice, grpc_slice* slice_out);
+  grpc_error_handle Push(const grpc_slice& slice, grpc_slice* slice_out);
 
-  grpc_error* Finished(grpc_error* error, bool reset_on_error);
+  grpc_error_handle Finished(grpc_error_handle error, bool reset_on_error);
 
   uint32_t remaining_bytes() const { return remaining_bytes_; }
 
  private:
-  static void NextLocked(void* arg, grpc_error* error_ignored);
-  static void OrphanLocked(void* arg, grpc_error* error_ignored);
+  static void NextLocked(void* arg, grpc_error_handle error_ignored);
+  static void OrphanLocked(void* arg, grpc_error_handle error_ignored);
 
   void MaybeCreateStreamDecompressionCtx();
 
@@ -309,7 +309,7 @@ struct grpc_chttp2_transport {
   /** is the transport destroying itself? */
   uint8_t destroying = false;
   /** has the upper layer closed the transport? */
-  grpc_error* closed_with_error = GRPC_ERROR_NONE;
+  grpc_error_handle closed_with_error = GRPC_ERROR_NONE;
 
   /** is there a read request to the endpoint outstanding? */
   uint8_t endpoint_reading = 1;
@@ -358,7 +358,7 @@ struct grpc_chttp2_transport {
 
   /** Set to a grpc_error object if a goaway frame is received. By default, set
    * to GRPC_ERROR_NONE */
-  grpc_error* goaway_error = GRPC_ERROR_NONE;
+  grpc_error_handle goaway_error = GRPC_ERROR_NONE;
 
   grpc_chttp2_sent_goaway_state sent_goaway_state = GRPC_CHTTP2_NO_GOAWAY_SEND;
 
@@ -394,7 +394,7 @@ struct grpc_chttp2_transport {
   grpc_chttp2_server_ping_recv_state ping_recv_state;
 
   /** parser for headers */
-  grpc_chttp2_hpack_parser hpack_parser;
+  grpc_core::HPackParser hpack_parser;
   /** simple one shot parsers */
   union {
     grpc_chttp2_window_update_parser window_update;
@@ -428,9 +428,9 @@ struct grpc_chttp2_transport {
   /* active parser */
   void* parser_data = nullptr;
   grpc_chttp2_stream* incoming_stream = nullptr;
-  grpc_error* (*parser)(void* parser_user_data, grpc_chttp2_transport* t,
-                        grpc_chttp2_stream* s, const grpc_slice& slice,
-                        int is_last);
+  grpc_error_handle (*parser)(void* parser_user_data, grpc_chttp2_transport* t,
+                              grpc_chttp2_stream* s, const grpc_slice& slice,
+                              int is_last);
 
   grpc_chttp2_write_cb* write_cb_pool = nullptr;
 
@@ -443,7 +443,7 @@ struct grpc_chttp2_transport {
 
   /* if non-NULL, close the transport with this error when writes are finished
    */
-  grpc_error* close_transport_on_writes_finished = GRPC_ERROR_NONE;
+  grpc_error_handle close_transport_on_writes_finished = GRPC_ERROR_NONE;
 
   /* a list of closures to run after writes are finished */
   grpc_closure_list run_after_write = GRPC_CLOSURE_LIST_INIT;
@@ -556,6 +556,7 @@ struct grpc_chttp2_stream {
   grpc_closure* recv_initial_metadata_ready = nullptr;
   bool* trailing_metadata_available = nullptr;
   grpc_core::OrphanablePtr<grpc_core::ByteStream>* recv_message;
+  bool* call_failed_before_recv_message = nullptr;
   grpc_closure* recv_message_ready = nullptr;
   grpc_metadata_batch* recv_trailing_metadata;
   grpc_closure* recv_trailing_metadata_finished = nullptr;
@@ -581,9 +582,9 @@ struct grpc_chttp2_stream {
   bool eos_sent = false;
 
   /** the error that resulted in this stream being read-closed */
-  grpc_error* read_closed_error = GRPC_ERROR_NONE;
+  grpc_error_handle read_closed_error = GRPC_ERROR_NONE;
   /** the error that resulted in this stream being write-closed */
-  grpc_error* write_closed_error = GRPC_ERROR_NONE;
+  grpc_error_handle write_closed_error = GRPC_ERROR_NONE;
 
   grpc_published_metadata_method published_metadata[2] = {};
   bool final_metadata_requested = false;
@@ -604,13 +605,14 @@ struct grpc_chttp2_stream {
    * true */
   grpc_slice_buffer unprocessed_incoming_frames_buffer;
   grpc_closure reset_byte_stream;
-  grpc_error* byte_stream_error = GRPC_ERROR_NONE; /* protected by t combiner */
-  bool received_last_frame = false;                /* protected by t combiner */
+  grpc_error_handle byte_stream_error =
+      GRPC_ERROR_NONE;              /* protected by t combiner */
+  bool received_last_frame = false; /* protected by t combiner */
 
   grpc_millis deadline = GRPC_MILLIS_INF_FUTURE;
 
   /** saw some stream level error */
-  grpc_error* forced_close_error = GRPC_ERROR_NONE;
+  grpc_error_handle forced_close_error = GRPC_ERROR_NONE;
   /** how many header frames have we received? */
   uint8_t header_frames_received = 0;
   /** parsing state for data frames */
@@ -696,12 +698,12 @@ struct grpc_chttp2_begin_write_result {
 };
 grpc_chttp2_begin_write_result grpc_chttp2_begin_write(
     grpc_chttp2_transport* t);
-void grpc_chttp2_end_write(grpc_chttp2_transport* t, grpc_error* error);
+void grpc_chttp2_end_write(grpc_chttp2_transport* t, grpc_error_handle error);
 
 /** Process one slice of incoming data; return 1 if the connection is still
     viable after reading, or 0 if the connection should be torn down */
-grpc_error* grpc_chttp2_perform_read(grpc_chttp2_transport* t,
-                                     const grpc_slice& slice);
+grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
+                                           const grpc_slice& slice);
 
 bool grpc_chttp2_list_add_writable_stream(grpc_chttp2_transport* t,
                                           grpc_chttp2_stream* s);
@@ -771,7 +773,8 @@ void grpc_chttp2_parsing_become_skip_parser(grpc_chttp2_transport* t);
 void grpc_chttp2_complete_closure_step(grpc_chttp2_transport* t,
                                        grpc_chttp2_stream* s,
                                        grpc_closure** pclosure,
-                                       grpc_error* error, const char* desc);
+                                       grpc_error_handle error,
+                                       const char* desc);
 
 #define GRPC_HEADER_SIZE_IN_BYTES 5
 #define MAX_SIZE_T (~(size_t)0)
@@ -791,10 +794,11 @@ void grpc_chttp2_complete_closure_step(grpc_chttp2_transport* t,
   } while (0)
 
 void grpc_chttp2_fake_status(grpc_chttp2_transport* t,
-                             grpc_chttp2_stream* stream, grpc_error* error);
+                             grpc_chttp2_stream* stream,
+                             grpc_error_handle error);
 void grpc_chttp2_mark_stream_closed(grpc_chttp2_transport* t,
                                     grpc_chttp2_stream* s, int close_reads,
-                                    int close_writes, grpc_error* error);
+                                    int close_writes, grpc_error_handle error);
 void grpc_chttp2_start_writing(grpc_chttp2_transport* t);
 
 #ifndef NDEBUG
@@ -862,7 +866,7 @@ void grpc_chttp2_mark_stream_writable(grpc_chttp2_transport* t,
                                       grpc_chttp2_stream* s);
 
 void grpc_chttp2_cancel_stream(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
-                               grpc_error* due_to_error);
+                               grpc_error_handle due_to_error);
 
 void grpc_chttp2_maybe_complete_recv_initial_metadata(grpc_chttp2_transport* t,
                                                       grpc_chttp2_stream* s);
@@ -872,14 +876,15 @@ void grpc_chttp2_maybe_complete_recv_trailing_metadata(grpc_chttp2_transport* t,
                                                        grpc_chttp2_stream* s);
 
 void grpc_chttp2_fail_pending_writes(grpc_chttp2_transport* t,
-                                     grpc_chttp2_stream* s, grpc_error* error);
+                                     grpc_chttp2_stream* s,
+                                     grpc_error_handle error);
 
 /** Set the default keepalive configurations, must only be called at
     initialization */
 void grpc_chttp2_config_default_keepalive_args(grpc_channel_args* args,
                                                bool is_client);
 
-void grpc_chttp2_retry_initiate_ping(void* tp, grpc_error* error);
+void grpc_chttp2_retry_initiate_ping(void* tp, grpc_error_handle error);
 
 void schedule_bdp_ping_locked(grpc_chttp2_transport* t);