grpc 1.47.0 → 1.48.0.pre1

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

@@ -20,42 +20,25 @@
 
 #include "src/core/ext/transport/chttp2/transport/frame_data.h"
 
-#include <string.h>
+#include <stdlib.h>
 
-#include "absl/base/attributes.h"
+#include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/slice_buffer.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/transport/chttp2/transport/internal.h"
-#include "src/core/lib/channel/channelz.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/slice/slice_refcount.h"
-#include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/transport/transport.h"
 
-grpc_chttp2_data_parser::~grpc_chttp2_data_parser() {
-  if (parsing_frame != nullptr) {
-    GRPC_ERROR_UNREF(parsing_frame->Finished(
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Parser destroyed"), false));
-  }
-  GRPC_ERROR_UNREF(error);
-}
-
-grpc_error_handle grpc_chttp2_data_parser_begin_frame(
-    grpc_chttp2_data_parser* /*parser*/, uint8_t flags, uint32_t stream_id,
-    grpc_chttp2_stream* s) {
+absl::Status grpc_chttp2_data_parser_begin_frame(uint8_t flags,
+                                                 uint32_t stream_id,
+                                                 grpc_chttp2_stream* s) {
   if (flags & ~GRPC_CHTTP2_DATA_FLAG_END_STREAM) {
-    return grpc_error_set_int(GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
-                                  "unsupported data flags: 0x%02x", flags)),
-                              GRPC_ERROR_INT_STREAM_ID,
-                              static_cast<intptr_t>(stream_id));
+    return absl::InternalError(absl::StrFormat(
+        "unsupported data flags: 0x%02x stream: %d", flags, stream_id));
   }
 
   if (flags & GRPC_CHTTP2_DATA_FLAG_END_STREAM) {
@@ -65,7 +48,7 @@ grpc_error_handle grpc_chttp2_data_parser_begin_frame(
     s->received_last_frame = false;
   }
 
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 void grpc_chttp2_encode_data(uint32_t id, grpc_slice_buffer* inbuf,
@@ -96,188 +79,58 @@ void grpc_chttp2_encode_data(uint32_t id, grpc_slice_buffer* inbuf,
   stats->data_bytes += write_bytes;
 }
 
-grpc_error_handle grpc_deframe_unprocessed_incoming_frames(
-    grpc_chttp2_data_parser* p, grpc_chttp2_stream* s,
-    grpc_slice_buffer* slices, grpc_slice* slice_out,
-    grpc_core::OrphanablePtr<grpc_core::ByteStream>* stream_out) {
+grpc_core::Poll<grpc_error_handle> grpc_deframe_unprocessed_incoming_frames(
+    grpc_chttp2_stream* s, uint32_t* min_progress_size,
+    grpc_core::SliceBuffer* stream_out, uint32_t* message_flags) {
+  grpc_slice_buffer* slices = &s->frame_storage;
   grpc_error_handle error = GRPC_ERROR_NONE;
-  grpc_chttp2_transport* t = s->t;
 
-  while (slices->count > 0) {
-    uint8_t* beg = nullptr;
-    uint8_t* end = nullptr;
-    uint8_t* cur = nullptr;
-
-    grpc_slice* slice = grpc_slice_buffer_peek_first(slices);
-    beg = GRPC_SLICE_START_PTR(*slice);
-    end = GRPC_SLICE_END_PTR(*slice);
-    cur = beg;
-    uint32_t message_flags;
+  if (slices->length < 5) {
+    if (min_progress_size != nullptr) *min_progress_size = 5 - slices->length;
+    return grpc_core::Pending{};
+  }
 
-    if (cur == end) {
-      grpc_slice_buffer_remove_first(slices);
-      continue;
-    }
+  uint8_t header[5];
+  grpc_slice_buffer_copy_first_into_buffer(slices, 5, header);
 
-    switch (p->state) {
-      case GRPC_CHTTP2_DATA_ERROR:
-        p->state = GRPC_CHTTP2_DATA_ERROR;
-        grpc_slice_buffer_remove_first(slices);
-        return GRPC_ERROR_REF(p->error);
-      case GRPC_CHTTP2_DATA_FH_0:
-        s->stats.incoming.framing_bytes++;
-        p->frame_type = *cur;
-        switch (p->frame_type) {
-          case 0:
-            p->is_frame_compressed = false; /* GPR_FALSE */
-            break;
-          case 1:
-            p->is_frame_compressed = true; /* GPR_TRUE */
-            break;
-          default:
-            p->error = GRPC_ERROR_CREATE_FROM_CPP_STRING(
-                absl::StrFormat("Bad GRPC frame type 0x%02x", p->frame_type));
-            p->error = grpc_error_set_int(p->error, GRPC_ERROR_INT_STREAM_ID,
-                                          static_cast<intptr_t>(s->id));
-            grpc_core::UniquePtr<char> dmp(
-                grpc_dump_slice(*slice, GPR_DUMP_HEX | GPR_DUMP_ASCII));
-            p->error = grpc_error_set_str(p->error, GRPC_ERROR_STR_RAW_BYTES,
-                                          dmp.get());
-            p->error =
-                grpc_error_set_int(p->error, GRPC_ERROR_INT_OFFSET, cur - beg);
-            p->state = GRPC_CHTTP2_DATA_ERROR;
-            grpc_slice_buffer_remove_first(slices);
-            return GRPC_ERROR_REF(p->error);
-        }
-        if (++cur == end) {
-          p->state = GRPC_CHTTP2_DATA_FH_1;
-          grpc_slice_buffer_remove_first(slices);
-          continue;
-        }
-        ABSL_FALLTHROUGH_INTENDED;
-      case GRPC_CHTTP2_DATA_FH_1:
-        s->stats.incoming.framing_bytes++;
-        p->frame_size = (static_cast<uint32_t>(*cur)) << 24;
-        if (++cur == end) {
-          p->state = GRPC_CHTTP2_DATA_FH_2;
-          grpc_slice_buffer_remove_first(slices);
-          continue;
-        }
-        ABSL_FALLTHROUGH_INTENDED;
-      case GRPC_CHTTP2_DATA_FH_2:
-        s->stats.incoming.framing_bytes++;
-        p->frame_size |= (static_cast<uint32_t>(*cur)) << 16;
-        if (++cur == end) {
-          p->state = GRPC_CHTTP2_DATA_FH_3;
-          grpc_slice_buffer_remove_first(slices);
-          continue;
-        }
-        ABSL_FALLTHROUGH_INTENDED;
-      case GRPC_CHTTP2_DATA_FH_3:
-        s->stats.incoming.framing_bytes++;
-        p->frame_size |= (static_cast<uint32_t>(*cur)) << 8;
-        if (++cur == end) {
-          p->state = GRPC_CHTTP2_DATA_FH_4;
-          grpc_slice_buffer_remove_first(slices);
-          continue;
-        }
-        ABSL_FALLTHROUGH_INTENDED;
-      case GRPC_CHTTP2_DATA_FH_4:
-        s->stats.incoming.framing_bytes++;
-        GPR_ASSERT(stream_out != nullptr);
-        GPR_ASSERT(p->parsing_frame == nullptr);
-        p->frame_size |= (static_cast<uint32_t>(*cur));
-        if (t->channelz_socket != nullptr) {
-          t->channelz_socket->RecordMessageReceived();
-        }
-        p->state = GRPC_CHTTP2_DATA_FRAME;
-        ++cur;
-        message_flags = 0;
-        if (p->is_frame_compressed) {
-          message_flags |= GRPC_WRITE_INTERNAL_COMPRESS;
-        }
-        p->parsing_frame = new grpc_core::Chttp2IncomingByteStream(
-            t, s, p->frame_size, message_flags);
-        stream_out->reset(p->parsing_frame);
-        if (p->parsing_frame->remaining_bytes() == 0) {
-          GRPC_ERROR_UNREF(p->parsing_frame->Finished(GRPC_ERROR_NONE, true));
-          p->parsing_frame = nullptr;
-          p->state = GRPC_CHTTP2_DATA_FH_0;
-        }
-        s->pending_byte_stream = true;
-        if (cur != end) {
-          grpc_slice_buffer_sub_first(slices, static_cast<size_t>(cur - beg),
-                                      static_cast<size_t>(end - beg));
-        } else {
-          grpc_slice_buffer_remove_first(slices);
-        }
-        return GRPC_ERROR_NONE;
-      case GRPC_CHTTP2_DATA_FRAME: {
-        GPR_ASSERT(p->parsing_frame != nullptr);
-        GPR_ASSERT(slice_out != nullptr);
-        if (cur == end) {
-          grpc_slice_buffer_remove_first(slices);
-          continue;
-        }
-        uint32_t remaining = static_cast<uint32_t>(end - cur);
-        if (remaining == p->frame_size) {
-          s->stats.incoming.data_bytes += remaining;
-          if (GRPC_ERROR_NONE !=
-              (error = p->parsing_frame->Push(
-                   grpc_slice_sub(*slice, static_cast<size_t>(cur - beg),
-                                  static_cast<size_t>(end - beg)),
-                   slice_out))) {
-            grpc_slice_buffer_remove_first(slices);
-            return error;
-          }
-          if (GRPC_ERROR_NONE !=
-              (error = p->parsing_frame->Finished(GRPC_ERROR_NONE, true))) {
-            grpc_slice_buffer_remove_first(slices);
-            return error;
-          }
-          p->parsing_frame = nullptr;
-          p->state = GRPC_CHTTP2_DATA_FH_0;
-          grpc_slice_buffer_remove_first(slices);
-          return GRPC_ERROR_NONE;
-        } else if (remaining < p->frame_size) {
-          s->stats.incoming.data_bytes += remaining;
-          if (GRPC_ERROR_NONE !=
-              (error = p->parsing_frame->Push(
-                   grpc_slice_sub(*slice, static_cast<size_t>(cur - beg),
-                                  static_cast<size_t>(end - beg)),
-                   slice_out))) {
-            return error;
-          }
-          p->frame_size -= remaining;
-          grpc_slice_buffer_remove_first(slices);
-          return GRPC_ERROR_NONE;
-        } else {
-          GPR_ASSERT(remaining > p->frame_size);
-          s->stats.incoming.data_bytes += p->frame_size;
-          if (GRPC_ERROR_NONE !=
-              p->parsing_frame->Push(
-                  grpc_slice_sub(
-                      *slice, static_cast<size_t>(cur - beg),
-                      static_cast<size_t>(cur + p->frame_size - beg)),
-                  slice_out)) {
-            grpc_slice_buffer_remove_first(slices);
-            return error;
-          }
-          if (GRPC_ERROR_NONE !=
-              (error = p->parsing_frame->Finished(GRPC_ERROR_NONE, true))) {
-            grpc_slice_buffer_remove_first(slices);
-            return error;
-          }
-          p->parsing_frame = nullptr;
-          p->state = GRPC_CHTTP2_DATA_FH_0;
-          cur += p->frame_size;
-          grpc_slice_buffer_sub_first(slices, static_cast<size_t>(cur - beg),
-                                      static_cast<size_t>(end - beg));
-          return GRPC_ERROR_NONE;
-        }
+  switch (header[0]) {
+    case 0:
+      if (message_flags != nullptr) *message_flags = 0;
+      break;
+    case 1:
+      if (message_flags != nullptr) {
+        *message_flags = GRPC_WRITE_INTERNAL_COMPRESS;
       }
+      break;
+    default:
+      error = GRPC_ERROR_CREATE_FROM_CPP_STRING(
+          absl::StrFormat("Bad GRPC frame type 0x%02x", header[0]));
+      error = grpc_error_set_int(error, GRPC_ERROR_INT_STREAM_ID,
+                                 static_cast<intptr_t>(s->id));
+      return error;
+  }
+
+  uint64_t length = (static_cast<uint32_t>(header[1]) << 24) |
+                    (static_cast<uint32_t>(header[2]) << 16) |
+                    (static_cast<uint32_t>(header[3]) << 8) |
+                    static_cast<uint32_t>(header[4]);
+
+  if (slices->length < length + 5) {
+    if (min_progress_size != nullptr) {
+      *min_progress_size = length + 5 - slices->length;
     }
+    return grpc_core::Pending{};
+  }
+
+  if (min_progress_size != nullptr) *min_progress_size = 0;
+
+  if (stream_out != nullptr) {
+    s->stats.incoming.framing_bytes += 5;
+    s->stats.incoming.data_bytes += length;
+    grpc_slice_buffer_move_first_into_buffer(slices, 5, header);
+    grpc_slice_buffer_move_first(slices, length, stream_out->c_slice_buffer());
   }
+
   return GRPC_ERROR_NONE;
 }
 
@@ -286,20 +139,9 @@ grpc_error_handle grpc_chttp2_data_parser_parse(void* /*parser*/,
                                                 grpc_chttp2_stream* s,
                                                 const grpc_slice& slice,
                                                 int is_last) {
-  if (!s->pending_byte_stream) {
-    grpc_slice_ref_internal(slice);
-    grpc_slice_buffer_add(&s->frame_storage, slice);
-    grpc_chttp2_maybe_complete_recv_message(t, s);
-  } else if (s->on_next) {
-    GPR_ASSERT(s->frame_storage.length == 0);
-    grpc_slice_ref_internal(slice);
-    grpc_slice_buffer_add(&s->unprocessed_incoming_frames_buffer, slice);
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, s->on_next, GRPC_ERROR_NONE);
-    s->on_next = nullptr;
-  } else {
-    grpc_slice_ref_internal(slice);
-    grpc_slice_buffer_add(&s->frame_storage, slice);
-  }
+  grpc_slice_ref_internal(slice);
+  grpc_slice_buffer_add(&s->frame_storage, slice);
+  grpc_chttp2_maybe_complete_recv_message(t, s);
 
   if (is_last && s->received_last_frame) {
     grpc_chttp2_mark_stream_closed(

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

@@ -25,45 +25,20 @@
 
 #include <stdint.h>
 
+#include "absl/status/status.h"
+
 #include <grpc/slice.h>
 
 #include "src/core/ext/transport/chttp2/transport/frame.h"
-#include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/transport/byte_stream.h"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/transport.h"
 
-typedef enum {
-  GRPC_CHTTP2_DATA_FH_0,
-  GRPC_CHTTP2_DATA_FH_1,
-  GRPC_CHTTP2_DATA_FH_2,
-  GRPC_CHTTP2_DATA_FH_3,
-  GRPC_CHTTP2_DATA_FH_4,
-  GRPC_CHTTP2_DATA_FRAME,
-  GRPC_CHTTP2_DATA_ERROR
-} grpc_chttp2_stream_state;
-
-namespace grpc_core {
-class Chttp2IncomingByteStream;
-}  // namespace grpc_core
-
-struct grpc_chttp2_data_parser {
-  grpc_chttp2_data_parser() = default;
-  ~grpc_chttp2_data_parser();
-
-  grpc_chttp2_stream_state state = GRPC_CHTTP2_DATA_FH_0;
-  uint8_t frame_type = 0;
-  uint32_t frame_size = 0;
-  grpc_error_handle error = GRPC_ERROR_NONE;
-
-  bool is_frame_compressed = false;
-  grpc_core::Chttp2IncomingByteStream* parsing_frame = nullptr;
-};
-
 /* start processing a new data frame */
-grpc_error_handle grpc_chttp2_data_parser_begin_frame(
-    grpc_chttp2_data_parser* parser, uint8_t flags, uint32_t stream_id,
-    grpc_chttp2_stream* s);
+absl::Status grpc_chttp2_data_parser_begin_frame(uint8_t flags,
+                                                 uint32_t stream_id,
+                                                 grpc_chttp2_stream* s);
 
 /* handle a slice of a data frame - is_last indicates the last slice of a
    frame */
@@ -78,9 +53,8 @@ void grpc_chttp2_encode_data(uint32_t id, grpc_slice_buffer* inbuf,
                              grpc_transport_one_way_stats* stats,
                              grpc_slice_buffer* outbuf);
 
-grpc_error_handle grpc_deframe_unprocessed_incoming_frames(
-    grpc_chttp2_data_parser* p, grpc_chttp2_stream* s,
-    grpc_slice_buffer* slices, grpc_slice* slice_out,
-    grpc_core::OrphanablePtr<grpc_core::ByteStream>* stream_out);
+grpc_core::Poll<grpc_error_handle> grpc_deframe_unprocessed_incoming_frames(
+    grpc_chttp2_stream* s, uint32_t* min_progress_size,
+    grpc_core::SliceBuffer* stream_out, uint32_t* message_flags);
 
 #endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_FRAME_DATA_H */

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

@@ -35,11 +35,9 @@
 #include "src/core/ext/transport/chttp2/transport/frame_goaway.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
-#include "src/core/ext/transport/chttp2/transport/stream_map.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 
 static uint8_t* fill_header(uint8_t* out, uint32_t length, uint8_t flags) {
@@ -119,22 +117,6 @@ grpc_error_handle grpc_chttp2_settings_parser_begin_frame(
   }
 }
 
-namespace {
-
-void StreamFlowControlWindowCheck(void* user_data, uint32_t /* key */,
-                                  void* stream) {
-  bool* error = static_cast<bool*>(user_data);
-  grpc_chttp2_stream* s = static_cast<grpc_chttp2_stream*>(stream);
-  if ((s->t->settings[GRPC_PEER_SETTINGS]
-                     [GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE] +
-       s->t->initial_window_update + s->flow_control->remote_window_delta()) >
-      ((1u << 31) - 1)) {
-    *error = true;
-  }
-}
-
-}  // namespace
-
 grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
                                                     grpc_chttp2_transport* t,
                                                     grpc_chttp2_stream* /*s*/,
@@ -219,12 +201,6 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
         if (grpc_wire_id_to_setting_id(parser->id, &id)) {
           const grpc_chttp2_setting_parameters* sp =
               &grpc_chttp2_settings_parameters[id];
-          // If flow control is disabled we skip these.
-          if (!t->flow_control->flow_control_enabled() &&
-              (id == GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE ||
-               id == GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE)) {
-            continue;
-          }
           if (parser->value < sp->min_value || parser->value > sp->max_value) {
             switch (sp->invalid_value_behavior) {
               case GRPC_CHTTP2_CLAMP_INVALID_VALUE:
@@ -250,23 +226,6 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
                       t->is_client ? "cli" : "svr",
                       static_cast<int>(t->initial_window_update));
             }
-            if (grpc_core::chttp2::
-                    g_test_only_transport_flow_control_window_check) {
-              bool error = false;
-              if (parser->value > grpc_core::chttp2::kMaxInitialWindowSize ||
-                  parser->value < grpc_core::chttp2::kMinInitialWindowSize) {
-                error = true;
-              } else {
-                grpc_chttp2_stream_map_for_each(
-                    &t->stream_map, StreamFlowControlWindowCheck, &error);
-              }
-              if (error) {
-                grpc_chttp2_goaway_append(
-                    t->last_new_stream_id, sp->error_value,
-                    grpc_slice_from_static_string("HTTP2 settings error"),
-                    &t->qbuf);
-              }
-            }
           }
           parser->incoming_settings[id] = parser->value;
           if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {

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

@@ -29,7 +29,6 @@
 
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
-#include "src/core/lib/gprpp/manual_constructor.h"
 
 grpc_slice grpc_chttp2_window_update_create(
     uint32_t id, uint32_t window_delta, grpc_transport_one_way_stats* stats) {
@@ -98,13 +97,9 @@ grpc_error_handle grpc_chttp2_window_update_parser_parse(
 
     if (t->incoming_stream_id != 0) {
       if (s != nullptr) {
-        s->flow_control->RecvUpdate(received_update);
-        if (grpc_core::chttp2::
-                g_test_only_transport_flow_control_window_check &&
-            s->flow_control->remote_window_delta() >
-                grpc_core::chttp2::kMaxWindowDelta) {
-          GPR_ASSERT(false);
-        }
+        grpc_core::chttp2::StreamFlowControl::OutgoingUpdateContext(
+            &s->flow_control)
+            .RecvUpdate(received_update);
         if (grpc_chttp2_list_remove_stalled_by_stream(t, s)) {
           grpc_chttp2_mark_stream_writable(t, s);
           grpc_chttp2_initiate_write(
@@ -112,10 +107,10 @@ grpc_error_handle grpc_chttp2_window_update_parser_parse(
         }
       }
     } else {
-      bool was_zero = t->flow_control->remote_window() <= 0;
-      t->flow_control->RecvUpdate(received_update);
-      bool is_zero = t->flow_control->remote_window() <= 0;
-      if (was_zero && !is_zero) {
+      grpc_core::chttp2::TransportFlowControl::OutgoingUpdateContext upd(
+          &t->flow_control);
+      upd.RecvUpdate(received_update);
+      if (upd.Finish() == grpc_core::chttp2::StallEdge::kUnstalled) {
         grpc_chttp2_initiate_write(
             t, GRPC_CHTTP2_INITIATE_WRITE_TRANSPORT_FLOW_CONTROL_UNSTALLED);
       }

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

@@ -31,6 +31,7 @@
 #include <utility>
 
 #include "absl/base/attributes.h"
+#include "absl/status/status.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
@@ -600,7 +601,7 @@ class HPackParser::Input {
   // Set the current error - allows the rest of the code not to need to pass
   // around StatusOr<> which would be prohibitive here.
   GPR_ATTRIBUTE_NOINLINE void SetError(grpc_error_handle error) {
-    if (error_ != GRPC_ERROR_NONE || eof_error_) {
+    if (!GRPC_ERROR_IS_NONE(error_) || eof_error_) {
       GRPC_ERROR_UNREF(error);
       return;
     }
@@ -613,7 +614,7 @@ class HPackParser::Input {
   template <typename F, typename T>
   GPR_ATTRIBUTE_NOINLINE T MaybeSetErrorAndReturn(F error_factory,
                                                   T return_value) {
-    if (error_ != GRPC_ERROR_NONE || eof_error_) return return_value;
+    if (!GRPC_ERROR_IS_NONE(error_) || eof_error_) return return_value;
     error_ = error_factory();
     begin_ = end_;
     return return_value;
@@ -623,7 +624,7 @@ class HPackParser::Input {
   // is a common case)
   template <typename T>
   T UnexpectedEOF(T return_value) {
-    if (error_ != GRPC_ERROR_NONE) return return_value;
+    if (!GRPC_ERROR_IS_NONE(error_)) return return_value;
     eof_error_ = true;
     return return_value;
   }
@@ -1089,7 +1090,7 @@ class HPackParser::Parser {
     auto r = EmitHeader(*md);
     // Add to the hpack table
     grpc_error_handle err = table_->Add(std::move(*md));
-    if (GPR_UNLIKELY(err != GRPC_ERROR_NONE)) {
+    if (GPR_UNLIKELY(!GRPC_ERROR_IS_NONE(err))) {
       input_->SetError(err);
       return false;
     };
@@ -1185,7 +1186,7 @@ class HPackParser::Parser {
     }
     (*dynamic_table_updates_allowed_)--;
     grpc_error_handle err = table_->SetCurrentTableSize(*size);
-    if (err != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(err)) {
       input_->SetError(err);
       return false;
     }
@@ -1360,7 +1361,7 @@ grpc_error_handle grpc_chttp2_header_parser_parse(void* hpack_parser,
     s->stats.incoming.header_bytes += GRPC_SLICE_LENGTH(slice);
   }
   grpc_error_handle error = parser->Parse(slice, is_last != 0);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     return error;
   }
   if (is_last) {

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

@@ -16,8 +16,6 @@
  *
  */
 
-// IWYU pragma: no_include <ext/alloc_traits.h>
-
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/transport/chttp2/transport/hpack_parser_table.h"