grpc 1.50.0-x86_64-linux → 1.51.0-x86_64-linux

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

@@ -48,6 +48,7 @@
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/transport/bdp_estimator.h"
@@ -130,7 +131,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
   const uint8_t* cur = beg;
   grpc_error_handle err;
 
-  if (cur == end) return GRPC_ERROR_NONE;
+  if (cur == end) return absl::OkStatus();
 
   switch (t->deframe_state) {
     case GRPC_DTS_CLIENT_PREFIX_0:
@@ -159,7 +160,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
     case GRPC_DTS_CLIENT_PREFIX_23:
       while (cur != end && t->deframe_state != GRPC_DTS_FH_0) {
         if (*cur != GRPC_CHTTP2_CLIENT_CONNECT_STRING[t->deframe_state]) {
-          return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
+          return GRPC_ERROR_CREATE(absl::StrFormat(
               "Connect string mismatch: expected '%c' (%d) got '%c' (%d) "
               "at byte %d",
               get_utf8_safe_char(
@@ -175,7 +176,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
             1 + static_cast<int>(t->deframe_state));
       }
       if (cur == end) {
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       }
     dts_fh_0:
       ABSL_FALLTHROUGH_INTENDED;
@@ -184,7 +185,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
       t->incoming_frame_size = (static_cast<uint32_t>(*cur)) << 16;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_1;
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       }
       ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_1:
@@ -192,7 +193,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
       t->incoming_frame_size |= (static_cast<uint32_t>(*cur)) << 8;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_2;
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       }
       ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_2:
@@ -200,7 +201,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
       t->incoming_frame_size |= *cur;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_3;
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       }
       ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_3:
@@ -208,7 +209,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
       t->incoming_frame_type = *cur;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_4;
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       }
       ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_4:
@@ -216,7 +217,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
       t->incoming_frame_flags = *cur;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_5;
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       }
       ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_5:
@@ -224,7 +225,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
       t->incoming_stream_id = ((static_cast<uint32_t>(*cur)) & 0x7f) << 24;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_6;
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       }
       ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_6:
@@ -232,7 +233,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur)) << 16;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_7;
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       }
       ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_7:
@@ -240,7 +241,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur)) << 8;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_8;
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       }
       ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_8:
@@ -248,31 +249,31 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur));
       t->deframe_state = GRPC_DTS_FRAME;
       err = init_frame_parser(t);
-      if (!GRPC_ERROR_IS_NONE(err)) {
+      if (!err.ok()) {
         return err;
       }
       if (t->incoming_frame_size == 0) {
         err = parse_frame_slice(t, grpc_empty_slice(), 1);
-        if (!GRPC_ERROR_IS_NONE(err)) {
+        if (!err.ok()) {
           return err;
         }
         t->incoming_stream = nullptr;
         if (++cur == end) {
           t->deframe_state = GRPC_DTS_FH_0;
-          return GRPC_ERROR_NONE;
+          return absl::OkStatus();
         }
         goto dts_fh_0; /* loop */
       } else if (t->incoming_frame_size >
                  t->settings[GRPC_ACKED_SETTINGS]
                             [GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE]) {
-        return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+        return GRPC_ERROR_CREATE(
             absl::StrFormat("Frame size %d is larger than max frame size %d",
                             t->incoming_frame_size,
                             t->settings[GRPC_ACKED_SETTINGS]
                                        [GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE]));
       }
       if (++cur == end) {
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       }
       ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FRAME:
@@ -283,12 +284,12 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
             grpc_slice_sub_no_ref(slice, static_cast<size_t>(cur - beg),
                                   static_cast<size_t>(end - beg)),
             1);
-        if (!GRPC_ERROR_IS_NONE(err)) {
+        if (!err.ok()) {
           return err;
         }
         t->deframe_state = GRPC_DTS_FH_0;
         t->incoming_stream = nullptr;
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       } else if (static_cast<uint32_t>(end - cur) > t->incoming_frame_size) {
         size_t cur_offset = static_cast<size_t>(cur - beg);
         err = parse_frame_slice(
@@ -296,7 +297,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
             grpc_slice_sub_no_ref(slice, cur_offset,
                                   cur_offset + t->incoming_frame_size),
             1);
-        if (!GRPC_ERROR_IS_NONE(err)) {
+        if (!err.ok()) {
           return err;
         }
         cur += t->incoming_frame_size;
@@ -308,34 +309,34 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
             grpc_slice_sub_no_ref(slice, static_cast<size_t>(cur - beg),
                                   static_cast<size_t>(end - beg)),
             0);
-        if (!GRPC_ERROR_IS_NONE(err)) {
+        if (!err.ok()) {
           return err;
         }
         t->incoming_frame_size -= static_cast<uint32_t>(end - cur);
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       }
-      GPR_UNREACHABLE_CODE(return GRPC_ERROR_NONE);
+      GPR_UNREACHABLE_CODE(return absl::OkStatus());
   }
 
-  GPR_UNREACHABLE_CODE(return GRPC_ERROR_NONE);
+  GPR_UNREACHABLE_CODE(return absl::OkStatus());
 }
 
 static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t) {
   if (t->is_first_frame &&
       t->incoming_frame_type != GRPC_CHTTP2_FRAME_SETTINGS) {
-    return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+    return GRPC_ERROR_CREATE(absl::StrCat(
         "Expected SETTINGS frame as the first frame, got frame type ",
         t->incoming_frame_type));
   }
   t->is_first_frame = false;
   if (t->expect_continuation_stream_id != 0) {
     if (t->incoming_frame_type != GRPC_CHTTP2_FRAME_CONTINUATION) {
-      return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+      return GRPC_ERROR_CREATE(
           absl::StrFormat("Expected CONTINUATION frame, got frame type %02x",
                           t->incoming_frame_type));
     }
     if (t->expect_continuation_stream_id != t->incoming_stream_id) {
-      return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
+      return GRPC_ERROR_CREATE(absl::StrFormat(
           "Expected CONTINUATION frame for grpc_chttp2_stream %08x, got "
           "grpc_chttp2_stream %08x",
           t->expect_continuation_stream_id, t->incoming_stream_id));
@@ -348,8 +349,7 @@ static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t) {
     case GRPC_CHTTP2_FRAME_HEADER:
       return init_header_frame_parser(t, 0);
     case GRPC_CHTTP2_FRAME_CONTINUATION:
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "Unexpected CONTINUATION frame");
+      return GRPC_ERROR_CREATE("Unexpected CONTINUATION frame");
     case GRPC_CHTTP2_FRAME_RST_STREAM:
       return init_rst_stream_parser(t);
     case GRPC_CHTTP2_FRAME_SETTINGS:
@@ -373,7 +373,7 @@ static grpc_error_handle skip_parser(void* /*parser*/,
                                      grpc_chttp2_stream* /*s*/,
                                      const grpc_slice& /*slice*/,
                                      int /*is_last*/) {
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 static HPackParser::Boundary hpack_boundary_type(grpc_chttp2_transport* t,
@@ -409,13 +409,13 @@ static grpc_error_handle init_header_skip_frame_parser(
                  [GRPC_CHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE],
       hpack_boundary_type(t, is_eoh), priority_type,
       hpack_parser_log_info(t, HPackParser::LogInfo::kDontKnow));
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 static grpc_error_handle init_non_header_skip_frame_parser(
     grpc_chttp2_transport* t) {
   t->parser = skip_parser;
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 void grpc_chttp2_parsing_become_skip_parser(grpc_chttp2_transport* t) {
@@ -473,7 +473,7 @@ error_handler:
     t->parser = grpc_chttp2_data_parser_parse;
     t->parser_data = nullptr;
     t->ping_state.last_ping_sent_time = grpc_core::Timestamp::InfPast();
-    return GRPC_ERROR_NONE;
+    return absl::OkStatus();
   } else if (s != nullptr) {
     /* handle stream errors by closing the stream */
     grpc_chttp2_mark_stream_closed(t, s, true, false,
@@ -549,7 +549,7 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
                    grpc_chttp2_stream_map_size(&t->stream_map) >=
                    t->settings[GRPC_ACKED_SETTINGS]
                               [GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS])) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Max stream count exceeded");
+      return GRPC_ERROR_CREATE("Max stream count exceeded");
     } else if (t->sent_goaway_state == GRPC_CHTTP2_FINAL_GOAWAY_SENT) {
       GRPC_CHTTP2_IF_TRACING(gpr_log(
           GPR_INFO,
@@ -595,6 +595,7 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
         if (s->trailing_metadata_available != nullptr) {
           *s->trailing_metadata_available = true;
         }
+        s->parsed_trailers_only = true;
         incoming_metadata_buffer = &s->trailing_metadata_buffer;
         frame_type = HPackParser::LogInfo::kTrailers;
       } else {
@@ -613,7 +614,7 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
       return init_header_skip_frame_parser(t, priority_type);
   }
   if (frame_type == HPackParser::LogInfo::kTrailers && !t->header_eof) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+    return GRPC_ERROR_CREATE(
         "Trailing metadata frame received without an end-o-stream");
   }
   t->hpack_parser.BeginFrame(
@@ -622,7 +623,7 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
                  [GRPC_CHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE],
       hpack_boundary_type(t, is_eoh), priority_type,
       hpack_parser_log_info(t, frame_type));
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 static grpc_error_handle init_window_update_frame_parser(
@@ -630,7 +631,7 @@ static grpc_error_handle init_window_update_frame_parser(
   grpc_error_handle err = grpc_chttp2_window_update_parser_begin_frame(
       &t->simple.window_update, t->incoming_frame_size,
       t->incoming_frame_flags);
-  if (!GRPC_ERROR_IS_NONE(err)) return err;
+  if (!err.ok()) return err;
   if (t->incoming_stream_id != 0) {
     grpc_chttp2_stream* s = t->incoming_stream =
         grpc_chttp2_parsing_lookup_stream(t, t->incoming_stream_id);
@@ -641,22 +642,22 @@ static grpc_error_handle init_window_update_frame_parser(
   }
   t->parser = grpc_chttp2_window_update_parser_parse;
   t->parser_data = &t->simple.window_update;
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 static grpc_error_handle init_ping_parser(grpc_chttp2_transport* t) {
   grpc_error_handle err = grpc_chttp2_ping_parser_begin_frame(
       &t->simple.ping, t->incoming_frame_size, t->incoming_frame_flags);
-  if (!GRPC_ERROR_IS_NONE(err)) return err;
+  if (!err.ok()) return err;
   t->parser = grpc_chttp2_ping_parser_parse;
   t->parser_data = &t->simple.ping;
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 static grpc_error_handle init_rst_stream_parser(grpc_chttp2_transport* t) {
   grpc_error_handle err = grpc_chttp2_rst_stream_parser_begin_frame(
       &t->simple.rst_stream, t->incoming_frame_size, t->incoming_frame_flags);
-  if (!GRPC_ERROR_IS_NONE(err)) return err;
+  if (!err.ok()) return err;
   grpc_chttp2_stream* s = t->incoming_stream =
       grpc_chttp2_parsing_lookup_stream(t, t->incoming_stream_id);
   if (!t->incoming_stream) {
@@ -665,28 +666,27 @@ static grpc_error_handle init_rst_stream_parser(grpc_chttp2_transport* t) {
   s->stats.incoming.framing_bytes += 9;
   t->parser = grpc_chttp2_rst_stream_parser_parse;
   t->parser_data = &t->simple.rst_stream;
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 static grpc_error_handle init_goaway_parser(grpc_chttp2_transport* t) {
   grpc_error_handle err = grpc_chttp2_goaway_parser_begin_frame(
       &t->goaway_parser, t->incoming_frame_size, t->incoming_frame_flags);
-  if (!GRPC_ERROR_IS_NONE(err)) return err;
+  if (!err.ok()) return err;
   t->parser = grpc_chttp2_goaway_parser_parse;
   t->parser_data = &t->goaway_parser;
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 static grpc_error_handle init_settings_frame_parser(grpc_chttp2_transport* t) {
   if (t->incoming_stream_id != 0) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "Settings frame received for grpc_chttp2_stream");
+    return GRPC_ERROR_CREATE("Settings frame received for grpc_chttp2_stream");
   }
 
   grpc_error_handle err = grpc_chttp2_settings_parser_begin_frame(
       &t->simple.settings, t->incoming_frame_size, t->incoming_frame_flags,
       t->settings[GRPC_PEER_SETTINGS]);
-  if (!GRPC_ERROR_IS_NONE(err)) {
+  if (!err.ok()) {
     return err;
   }
   if (t->incoming_frame_flags & GRPC_CHTTP2_FLAG_ACK) {
@@ -702,7 +702,7 @@ static grpc_error_handle init_settings_frame_parser(grpc_chttp2_transport* t) {
   }
   t->parser = grpc_chttp2_settings_parser_parse;
   t->parser_data = &t->simple.settings;
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 static grpc_error_handle parse_frame_slice(grpc_chttp2_transport* t,
@@ -711,11 +711,12 @@ static grpc_error_handle parse_frame_slice(grpc_chttp2_transport* t,
   grpc_chttp2_stream* s = t->incoming_stream;
   grpc_error_handle err = t->parser(t->parser_data, t, s, slice, is_last);
   intptr_t unused;
-  if (GPR_LIKELY(GRPC_ERROR_IS_NONE(err))) {
+  if (GPR_LIKELY(err.ok())) {
     return err;
-  } else if (grpc_error_get_int(err, GRPC_ERROR_INT_STREAM_ID, &unused)) {
+  } else if (grpc_error_get_int(err, grpc_core::StatusIntProperty::kStreamId,
+                                &unused)) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
-      gpr_log(GPR_ERROR, "%s", grpc_error_std_string(err).c_str());
+      gpr_log(GPR_ERROR, "%s", grpc_core::StatusToString(err).c_str());
     }
     grpc_chttp2_parsing_become_skip_parser(t);
     if (s) {
@@ -723,8 +724,6 @@ static grpc_error_handle parse_frame_slice(grpc_chttp2_transport* t,
       grpc_chttp2_add_rst_stream_to_next_write(t, t->incoming_stream_id,
                                                GRPC_HTTP2_PROTOCOL_ERROR,
                                                &s->stats.outgoing);
-    } else {
-      GRPC_ERROR_UNREF(err);
     }
   }
   return err;

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

@@ -24,7 +24,7 @@
 
 namespace grpc_core {
 
-uint32_t VarintLength(uint32_t tail_value) {
+size_t VarintLength(size_t tail_value) {
   if (tail_value < (1 << 7)) {
     return 2;
   } else if (tail_value < (1 << 14)) {
@@ -38,8 +38,7 @@ uint32_t VarintLength(uint32_t tail_value) {
   }
 }
 
-void VarintWriteTail(uint32_t tail_value, uint8_t* target,
-                     uint32_t tail_length) {
+void VarintWriteTail(size_t tail_value, uint8_t* target, size_t tail_length) {
   switch (tail_length) {
     case 5:
       target[4] = static_cast<uint8_t>((tail_value >> 28) | 0x80);

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

@@ -22,6 +22,9 @@
 #include <grpc/support/port_platform.h>
 
 #include <stdint.h>
+#include <stdlib.h>
+
+#include <grpc/support/log.h>
 
 /* Helpers for hpack varint encoding */
 
@@ -36,22 +39,22 @@ constexpr uint32_t MaxInVarintPrefix(uint8_t prefix_bits) {
 /* length of a value that needs varint tail encoding (it's bigger than can be
    bitpacked into the opcode byte) - returned value includes the length of the
    opcode byte */
-uint32_t VarintLength(uint32_t tail_value);
-void VarintWriteTail(uint32_t tail_value, uint8_t* target,
-                     uint32_t tail_length);
+size_t VarintLength(size_t tail_value);
+void VarintWriteTail(size_t tail_value, uint8_t* target, size_t tail_length);
 
 template <uint8_t kPrefixBits>
 class VarintWriter {
  public:
   static constexpr uint32_t kMaxInPrefix = MaxInVarintPrefix(kPrefixBits);
 
-  explicit VarintWriter(uint32_t value)
+  explicit VarintWriter(size_t value)
       : value_(value),
         length_(value < kMaxInPrefix ? 1 : VarintLength(value - kMaxInPrefix)) {
+    GPR_ASSERT(value <= UINT32_MAX);
   }
 
-  uint32_t value() const { return value_; }
-  uint32_t length() const { return length_; }
+  size_t value() const { return value_; }
+  size_t length() const { return length_; }
 
   void Write(uint8_t prefix, uint8_t* target) const {
     if (length_ == 1) {
@@ -63,9 +66,9 @@ class VarintWriter {
   }
 
  private:
-  const uint32_t value_;
+  const size_t value_;
   // length required to bitpack value_
-  const uint32_t length_;
+  const size_t length_;
 };
 
 }  // namespace grpc_core

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

@@ -24,10 +24,12 @@
 #include <algorithm>
 #include <string>
 
+#include "absl/status/status.h"
 #include "absl/types/optional.h"
 
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
+#include <grpc/status.h>
 #include <grpc/support/log.h>
 
 // IWYU pragma: no_include "src/core/lib/gprpp/orphanable.h"
@@ -47,6 +49,7 @@
 #include "src/core/ext/transport/chttp2/transport/stream_map.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/debug/stats.h"
+#include "src/core/lib/debug/stats_data.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/ref_counted.h"
@@ -58,7 +61,6 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/slice/slice.h"
-#include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/transport/bdp_estimator.h"
 #include "src/core/lib/transport/http2_errors.h"
 #include "src/core/lib/transport/metadata_batch.h"
@@ -169,7 +171,7 @@ static void maybe_initiate_ping(grpc_chttp2_transport* t) {
                          &pq->lists[GRPC_CHTTP2_PCL_INFLIGHT]);
   grpc_slice_buffer_add(&t->outbuf,
                         grpc_chttp2_ping_create(false, pq->inflight_id));
-  GRPC_STATS_INC_HTTP2_PINGS_SENT();
+  grpc_core::global_stats().IncrementHttp2PingsSent();
   if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
       GRPC_TRACE_FLAG_ENABLED(grpc_bdp_estimator_trace) ||
       GRPC_TRACE_FLAG_ENABLED(grpc_keepalive_trace)) {
@@ -193,13 +195,12 @@ static bool update_list(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
     grpc_chttp2_write_cb* next = cb->next;
     if (cb->call_at_byte <= *ctr) {
       sched_any = true;
-      finish_write_cb(t, s, cb, GRPC_ERROR_REF(error));
+      finish_write_cb(t, s, cb, error);
     } else {
       add_to_write_list(list, cb);
     }
     cb = next;
   }
-  GRPC_ERROR_UNREF(error);
   return sched_any;
 }
 
@@ -264,7 +265,7 @@ namespace {
 class WriteContext {
  public:
   explicit WriteContext(grpc_chttp2_transport* t) : t_(t) {
-    GRPC_STATS_INC_HTTP2_WRITES_BEGUN();
+    grpc_core::global_stats().IncrementHttp2WritesBegun();
   }
 
   void FlushSettings() {
@@ -277,7 +278,7 @@ class WriteContext {
       t_->force_send_settings = false;
       t_->dirtied_local_settings = false;
       t_->sent_local_settings = true;
-      GRPC_STATS_INC_HTTP2_SETTINGS_WRITES();
+      grpc_core::global_stats().IncrementHttp2SettingsWrites();
     }
   }
 
@@ -317,7 +318,7 @@ class WriteContext {
   void UpdateStreamsNoLongerStalled() {
     grpc_chttp2_stream* s;
     while (grpc_chttp2_list_pop_stalled_by_transport(t_, &s)) {
-      if (GRPC_ERROR_IS_NONE(t_->closed_with_error) &&
+      if (t_->closed_with_error.ok() &&
           grpc_chttp2_list_add_writable_stream(t_, s)) {
         if (!s->refcount->refs.RefIfNonZero()) {
           grpc_chttp2_list_remove_writable_stream(t_, s);
@@ -412,7 +413,7 @@ class DataSendContext {
             t_, s_,
             static_cast<int64_t>(s_->sending_bytes - sending_bytes_before_),
             &s_->on_flow_controlled_cbs, &s_->flow_controlled_bytes_flowed,
-            GRPC_ERROR_NONE)) {
+            absl::OkStatus())) {
       write_context_->NoteScheduledResults();
     }
   }
@@ -474,7 +475,7 @@ class StreamWriteContext {
     s_->sent_initial_metadata = true;
     write_context_->NoteScheduledResults();
     grpc_chttp2_complete_closure_step(
-        t_, s_, &s_->send_initial_metadata_finished, GRPC_ERROR_NONE,
+        t_, s_, &s_->send_initial_metadata_finished, absl::OkStatus(),
         "send_initial_metadata_finished");
   }
 
@@ -503,11 +504,11 @@ class StreamWriteContext {
 
     if (!data_send_context.AnyOutgoing()) {
       if (t_->flow_control.remote_window() <= 0) {
-        GRPC_STATS_INC_HTTP2_TRANSPORT_STALLS();
+        grpc_core::global_stats().IncrementHttp2TransportStalls();
         report_stall(t_, s_, "transport");
         grpc_chttp2_list_add_stalled_by_transport(t_, s_);
       } else if (data_send_context.stream_remote_window() <= 0) {
-        GRPC_STATS_INC_HTTP2_STREAM_STALLS();
+        grpc_core::global_stats().IncrementHttp2StreamStalls();
         report_stall(t_, s_, "stream");
         grpc_chttp2_list_add_stalled_by_stream(t_, s_);
       }
@@ -568,7 +569,7 @@ class StreamWriteContext {
 
     write_context_->NoteScheduledResults();
     grpc_chttp2_complete_closure_step(
-        t_, s_, &s_->send_trailing_metadata_finished, GRPC_ERROR_NONE,
+        t_, s_, &s_->send_trailing_metadata_finished, absl::OkStatus(),
         "send_trailing_metadata_finished");
   }
 
@@ -601,7 +602,7 @@ class StreamWriteContext {
                            s_->id, GRPC_HTTP2_NO_ERROR, &s_->stats.outgoing));
     }
     grpc_chttp2_mark_stream_closed(t_, s_, !t_->is_client, true,
-                                   GRPC_ERROR_NONE);
+                                   absl::OkStatus());
   }
 
   WriteContext* const write_context_;
@@ -673,11 +674,10 @@ void grpc_chttp2_end_write(grpc_chttp2_transport* t, grpc_error_handle error) {
     if (s->sending_bytes != 0) {
       update_list(t, s, static_cast<int64_t>(s->sending_bytes),
                   &s->on_write_finished_cbs, &s->flow_controlled_bytes_written,
-                  GRPC_ERROR_REF(error));
+                  error);
       s->sending_bytes = 0;
     }
     GRPC_CHTTP2_STREAM_UNREF(s, "chttp2_writing:end");
   }
-  grpc_slice_buffer_reset_and_unref_internal(&t->outbuf);
-  GRPC_ERROR_UNREF(error);
+  grpc_slice_buffer_reset_and_unref(&t->outbuf);
 }