grpc 1.60.2 → 1.61.0.pre2

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

@@ -0,0 +1,214 @@
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_FRAME_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_FRAME_H
+
+#include <grpc/support/port_platform.h>
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "absl/types/variant.h"
+
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/slice/slice_buffer.h"
+
+namespace grpc_core {
+
+///////////////////////////////////////////////////////////////////////////////
+// Frame types
+//
+// Define structs for each kind of frame that chttp2 reasons about.
+//
+// Each struct gets the members defined by the HTTP/2 spec for that frame type
+// *that the semantic layers of chttp2 neead to reason about*.
+//
+// That means, for instance, that we drop padding and prioritization data from
+// these structs, as they are handled by the HTTP/2 framing layer and are
+// meaningless to the semantic layers above.
+//
+// If a frame type is associated with a stream, it has a stream_id member.
+// If that frame type is only used at the channel layer it does not.
+//
+// Instead of carrying bitfields of flags like the wire format, we instead
+// declare a bool per flag to make producing/consuming code easier to write.
+//
+// Equality operators are defined for use in unit tests.
+
+// DATA frame
+struct Http2DataFrame {
+  uint32_t stream_id = 0;
+  bool end_stream = false;
+  SliceBuffer payload;
+
+  bool operator==(const Http2DataFrame& other) const {
+    return stream_id == other.stream_id && end_stream == other.end_stream &&
+           payload.JoinIntoString() == other.payload.JoinIntoString();
+  }
+};
+
+// HEADER frame
+struct Http2HeaderFrame {
+  uint32_t stream_id = 0;
+  bool end_headers = false;
+  bool end_stream = false;
+  SliceBuffer payload;
+
+  bool operator==(const Http2HeaderFrame& other) const {
+    return stream_id == other.stream_id && end_headers == other.end_headers &&
+           end_stream == other.end_stream &&
+           payload.JoinIntoString() == other.payload.JoinIntoString();
+  }
+};
+
+// CONTINUATION frame
+struct Http2ContinuationFrame {
+  uint32_t stream_id = 0;
+  bool end_headers = false;
+  SliceBuffer payload;
+
+  bool operator==(const Http2ContinuationFrame& other) const {
+    return stream_id == other.stream_id && end_headers == other.end_headers &&
+           payload.JoinIntoString() == other.payload.JoinIntoString();
+  }
+};
+
+// RST_STREAM frame
+struct Http2RstStreamFrame {
+  uint32_t stream_id = 0;
+  uint32_t error_code = 0;
+
+  bool operator==(const Http2RstStreamFrame& other) const {
+    return stream_id == other.stream_id && error_code == other.error_code;
+  }
+};
+
+// SETTINGS frame
+struct Http2SettingsFrame {
+  struct Setting {
+    Setting(uint16_t id, uint32_t value) : id(id), value(value) {}
+
+    uint16_t id;
+    uint32_t value;
+
+    bool operator==(const Setting& other) const {
+      return id == other.id && value == other.value;
+    }
+  };
+  bool ack = false;
+  std::vector<Setting> settings;
+
+  bool operator==(const Http2SettingsFrame& other) const {
+    return ack == other.ack && settings == other.settings;
+  }
+};
+
+// PING frame
+struct Http2PingFrame {
+  bool ack = false;
+  uint64_t opaque = 0;
+
+  bool operator==(const Http2PingFrame& other) const {
+    return ack == other.ack && opaque == other.opaque;
+  }
+};
+
+// GOAWAY frame
+struct Http2GoawayFrame {
+  uint32_t last_stream_id = 0;
+  uint32_t error_code = 0;
+  Slice debug_data;
+
+  bool operator==(const Http2GoawayFrame& other) const {
+    return last_stream_id == other.last_stream_id &&
+           error_code == other.error_code &&
+           debug_data.as_string_view() == other.debug_data.as_string_view();
+  }
+};
+
+// WINDOW_UPDATE frame
+struct Http2WindowUpdateFrame {
+  uint32_t stream_id;
+  uint32_t increment;
+
+  bool operator==(const Http2WindowUpdateFrame& other) const {
+    return stream_id == other.stream_id && increment == other.increment;
+  }
+};
+
+// Type of frame was unknown (and should be ignored)
+struct Http2UnknownFrame {
+  bool operator==(const Http2UnknownFrame&) const { return true; }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Frame variant
+//
+// A union of all the frame types above, so that we may pass around an
+// arbitrary frame between layers as appropriate.
+using Http2Frame =
+    absl::variant<Http2DataFrame, Http2HeaderFrame, Http2ContinuationFrame,
+                  Http2RstStreamFrame, Http2SettingsFrame, Http2PingFrame,
+                  Http2GoawayFrame, Http2WindowUpdateFrame, Http2UnknownFrame>;
+
+///////////////////////////////////////////////////////////////////////////////
+// Frame header
+//
+// Define a struct for the frame header.
+// Parsing this type is the first step in parsing a frame.
+// No validation on the header is done during parsing - the fields should be
+// instead interpreted by the frame type parser.
+struct Http2FrameHeader {
+  uint32_t length;
+  uint8_t type;
+  uint8_t flags;
+  uint32_t stream_id;
+  // Serialize header to 9 byte long buffer output
+  // Crashes if length > 16777215 (as this is unencodable)
+  void Serialize(uint8_t* output) const;
+  // Parse header from 9 byte long buffer input
+  static Http2FrameHeader Parse(const uint8_t* input);
+  std::string ToString() const;
+
+  bool operator==(const Http2FrameHeader& other) const {
+    return length == other.length && type == other.type &&
+           flags == other.flags && stream_id == other.stream_id;
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Parsing & serialization
+
+// Given a frame header and a payload, parse the payload into a frame and
+// return it.
+// If this function returns an error, that should be considered a connection
+// error.
+// If a frame should simply be ignored, this function returns a
+// Http2UnknownFrame.
+// It is expected that hdr.length == payload.Length().
+absl::StatusOr<Http2Frame> ParseFramePayload(const Http2FrameHeader& hdr,
+                                             SliceBuffer payload);
+
+// Serialize frame and append to out, leaves frames in an unknown state (may
+// move things out of frames)
+void Serialize(absl::Span<Http2Frame> frames, SliceBuffer& out);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_FRAME_H

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

@@ -126,7 +126,7 @@ grpc_error_handle grpc_chttp2_rst_stream_parser_parse(void* parser,
           grpc_core::StatusIntProperty::kHttp2Error,
           static_cast<intptr_t>(reason));
     }
-    if (grpc_core::IsPingOnRstStreamEnabled() && !t->is_client &&
+    if (!t->is_client &&
         absl::Bernoulli(t->bitgen, t->ping_on_rst_stream_percent / 100.0)) {
       ++t->num_pending_induced_frames;
       t->ping_callbacks.RequestPing();

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

@@ -33,6 +33,7 @@
 
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
 #include "src/core/ext/transport/chttp2/transport/frame_goaway.h"
+#include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/ext/transport/chttp2/transport/http_trace.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
@@ -55,38 +56,6 @@ static uint8_t* fill_header(uint8_t* out, uint32_t length, uint8_t flags) {
   return out;
 }
 
-grpc_slice grpc_chttp2_settings_create(uint32_t* old_settings,
-                                       const uint32_t* new_settings,
-                                       uint32_t force_mask, size_t count) {
-  size_t i;
-  uint32_t n = 0;
-  grpc_slice output;
-  uint8_t* p;
-
-  for (i = 0; i < count; i++) {
-    n += (new_settings[i] != old_settings[i] || (force_mask & (1u << i)) != 0);
-  }
-
-  output = GRPC_SLICE_MALLOC(9 + 6 * n);
-  p = fill_header(GRPC_SLICE_START_PTR(output), 6 * n, 0);
-
-  for (i = 0; i < count; i++) {
-    if (new_settings[i] != old_settings[i] || (force_mask & (1u << i)) != 0) {
-      *p++ = static_cast<uint8_t>(grpc_setting_id_to_wire_id[i] >> 8);
-      *p++ = static_cast<uint8_t>(grpc_setting_id_to_wire_id[i]);
-      *p++ = static_cast<uint8_t>(new_settings[i] >> 24);
-      *p++ = static_cast<uint8_t>(new_settings[i] >> 16);
-      *p++ = static_cast<uint8_t>(new_settings[i] >> 8);
-      *p++ = static_cast<uint8_t>(new_settings[i]);
-      old_settings[i] = new_settings[i];
-    }
-  }
-
-  GPR_ASSERT(p == GRPC_SLICE_END_PTR(output));
-
-  return output;
-}
-
 grpc_slice grpc_chttp2_settings_ack_create(void) {
   grpc_slice output = GRPC_SLICE_MALLOC(9);
   fill_header(GRPC_SLICE_START_PTR(output), 0, GRPC_CHTTP2_FLAG_ACK);
@@ -95,10 +64,9 @@ grpc_slice grpc_chttp2_settings_ack_create(void) {
 
 grpc_error_handle grpc_chttp2_settings_parser_begin_frame(
     grpc_chttp2_settings_parser* parser, uint32_t length, uint8_t flags,
-    uint32_t* settings) {
-  parser->target_settings = settings;
-  memcpy(parser->incoming_settings, settings,
-         GRPC_CHTTP2_NUM_SETTINGS * sizeof(uint32_t));
+    grpc_core::Http2Settings& settings) {
+  parser->target_settings = &settings;
+  parser->incoming_settings.Init(settings);
   parser->is_ack = 0;
   parser->state = GRPC_CHTTP2_SPS_ID0;
   if (flags == GRPC_CHTTP2_FLAG_ACK) {
@@ -125,7 +93,6 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
       static_cast<grpc_chttp2_settings_parser*>(p);
   const uint8_t* cur = GRPC_SLICE_START_PTR(slice);
   const uint8_t* end = GRPC_SLICE_END_PTR(slice);
-  grpc_chttp2_setting_id id;
 
   if (parser->is_ack) {
     return absl::OkStatus();
@@ -137,8 +104,7 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
         if (cur == end) {
           parser->state = GRPC_CHTTP2_SPS_ID0;
           if (is_last) {
-            memcpy(parser->target_settings, parser->incoming_settings,
-                   GRPC_CHTTP2_NUM_SETTINGS * sizeof(uint32_t));
+            *parser->target_settings = *parser->incoming_settings;
             t->num_pending_induced_frames++;
             grpc_slice_buffer_add(&t->qbuf, grpc_chttp2_settings_ack_create());
             grpc_chttp2_initiate_write(t,
@@ -187,7 +153,7 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
         parser->value |= (static_cast<uint32_t>(*cur)) << 8;
         cur++;
         ABSL_FALLTHROUGH_INTENDED;
-      case GRPC_CHTTP2_SPS_VAL3:
+      case GRPC_CHTTP2_SPS_VAL3: {
         if (cur == end) {
           parser->state = GRPC_CHTTP2_SPS_VAL3;
           return absl::OkStatus();
@@ -197,47 +163,35 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
         parser->value |= *cur;
         cur++;
 
-        if (grpc_wire_id_to_setting_id(parser->id, &id)) {
-          const grpc_chttp2_setting_parameters* sp =
-              &grpc_chttp2_settings_parameters[id];
-          if (parser->value < sp->min_value || parser->value > sp->max_value) {
-            switch (sp->invalid_value_behavior) {
-              case GRPC_CHTTP2_CLAMP_INVALID_VALUE:
-                parser->value = grpc_core::Clamp(parser->value, sp->min_value,
-                                                 sp->max_value);
-                break;
-              case GRPC_CHTTP2_DISCONNECT_ON_INVALID_VALUE:
-                grpc_chttp2_goaway_append(
-                    t->last_new_stream_id, sp->error_value,
-                    grpc_slice_from_static_string("HTTP2 settings error"),
-                    &t->qbuf);
-                return GRPC_ERROR_CREATE(absl::StrFormat(
-                    "invalid value %u passed for %s", parser->value, sp->name));
-            }
-          }
-          if (id == GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE &&
-              parser->incoming_settings[id] != parser->value) {
-            t->initial_window_update += static_cast<int64_t>(parser->value) -
-                                        parser->incoming_settings[id];
-            if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
-                GRPC_TRACE_FLAG_ENABLED(grpc_flowctl_trace)) {
-              gpr_log(GPR_INFO, "%p[%s] adding %d for initial_window change", t,
-                      t->is_client ? "cli" : "svr",
-                      static_cast<int>(t->initial_window_update));
-            }
-          }
-          parser->incoming_settings[id] = parser->value;
-          if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
-            gpr_log(GPR_INFO, "CHTTP2:%s:%s: got setting %s = %d",
-                    t->is_client ? "CLI" : "SVR",
-                    std::string(t->peer_string.as_string_view()).c_str(),
-                    sp->name, parser->value);
+        if (parser->id == grpc_core::Http2Settings::kInitialWindowSizeWireId) {
+          t->initial_window_update +=
+              static_cast<int64_t>(parser->value) -
+              parser->incoming_settings->initial_window_size();
+          if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
+              GRPC_TRACE_FLAG_ENABLED(grpc_flowctl_trace)) {
+            gpr_log(GPR_INFO, "%p[%s] adding %d for initial_window change", t,
+                    t->is_client ? "cli" : "svr",
+                    static_cast<int>(t->initial_window_update));
           }
-        } else if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
-          gpr_log(GPR_DEBUG, "CHTTP2: Ignoring unknown setting %d (value %d)",
-                  parser->id, parser->value);
         }
-        break;
+        auto error =
+            parser->incoming_settings->Apply(parser->id, parser->value);
+        if (error != GRPC_HTTP2_NO_ERROR) {
+          grpc_chttp2_goaway_append(
+              t->last_new_stream_id, error,
+              grpc_slice_from_static_string("HTTP2 settings error"), &t->qbuf);
+          return GRPC_ERROR_CREATE(absl::StrFormat(
+              "invalid value %u passed for %s", parser->value,
+              grpc_core::Http2Settings::WireIdToName(parser->id).c_str()));
+        }
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
+          gpr_log(GPR_INFO, "CHTTP2:%s:%s: got setting %s = %d",
+                  t->is_client ? "CLI" : "SVR",
+                  std::string(t->peer_string.as_string_view()).c_str(),
+                  grpc_core::Http2Settings::WireIdToName(parser->id).c_str(),
+                  parser->value);
+        }
+      } break;
     }
   }
 }

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

@@ -28,6 +28,7 @@
 
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
+#include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/iomgr/error.h"
 
 typedef enum {
@@ -41,22 +42,18 @@ typedef enum {
 
 struct grpc_chttp2_settings_parser {
   grpc_chttp2_settings_parse_state state;
-  uint32_t* target_settings;
+  grpc_core::Http2Settings* target_settings;
+  grpc_core::ManualConstructor<grpc_core::Http2Settings> incoming_settings;
   uint8_t is_ack;
   uint16_t id;
   uint32_t value;
-  uint32_t incoming_settings[GRPC_CHTTP2_NUM_SETTINGS];
 };
-// Create a settings frame by diffing old & new, and updating old to be new
-grpc_slice grpc_chttp2_settings_create(uint32_t* old_settings,
-                                       const uint32_t* new_settings,
-                                       uint32_t force_mask, size_t count);
 // Create an ack settings frame
 grpc_slice grpc_chttp2_settings_ack_create(void);
 
 grpc_error_handle grpc_chttp2_settings_parser_begin_frame(
     grpc_chttp2_settings_parser* parser, uint32_t length, uint8_t flags,
-    uint32_t* settings);
+    grpc_core::Http2Settings& settings);
 grpc_error_handle grpc_chttp2_settings_parser_parse(void* parser,
                                                     grpc_chttp2_transport* t,
                                                     grpc_chttp2_stream* s,

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

@@ -91,14 +91,12 @@ constexpr Base64InverseTable kBase64InverseTable;
 class HPackParser::Input {
  public:
   Input(grpc_slice_refcount* current_slice_refcount, const uint8_t* begin,
-        const uint8_t* end, absl::BitGenRef bitsrc,
-        HpackParseResult& frame_error, HpackParseResult& field_error)
+        const uint8_t* end, absl::BitGenRef bitsrc, HpackParseResult& error)
       : current_slice_refcount_(current_slice_refcount),
         begin_(begin),
         end_(end),
         frontier_(begin),
-        frame_error_(frame_error),
-        field_error_(field_error),
+        error_(error),
         bitsrc_(bitsrc) {}
 
   // If input is backed by a slice, retrieve its refcount. If not, return
@@ -217,18 +215,14 @@ class HPackParser::Input {
 
   // Check if we saw an EOF
   bool eof_error() const {
-    return min_progress_size_ != 0 || frame_error_.connection_error();
-  }
-
-  // Reset the field error to be ok
-  void ClearFieldError() {
-    if (field_error_.ok()) return;
-    field_error_ = HpackParseResult();
+    return min_progress_size_ != 0 || error_.connection_error();
   }
 
   // Minimum number of bytes to unstuck the current parse
   size_t min_progress_size() const { return min_progress_size_; }
 
+  bool has_error() const { return !error_.ok(); }
+
   // Set the current error - tweaks the error to include a stream id so that
   // chttp2 does not close the connection.
   // Intended for errors that are specific to a stream and recoverable.
@@ -252,7 +246,10 @@ class HPackParser::Input {
   // read prior to being able to get further in this parse.
   void UnexpectedEOF(size_t min_progress_size) {
     GPR_ASSERT(min_progress_size > 0);
-    if (eof_error()) return;
+    if (min_progress_size_ != 0 || error_.connection_error()) {
+      GPR_DEBUG_ASSERT(eof_error());
+      return;
+    }
     // Set min progress size, taking into account bytes parsed already but not
     // consumed.
     min_progress_size_ = min_progress_size + (begin_ - frontier_);
@@ -305,18 +302,13 @@ class HPackParser::Input {
   // Do not use this directly, instead use SetErrorAndContinueParsing or
   // SetErrorAndStopParsing.
   void SetError(HpackParseResult error) {
-    SetErrorFor(frame_error_, error);
-    SetErrorFor(field_error_, std::move(error));
-  }
-
-  void SetErrorFor(HpackParseResult& error, HpackParseResult new_error) {
-    if (!error.ok() || min_progress_size_ > 0) {
-      if (new_error.connection_error() && !error.connection_error()) {
-        error = std::move(new_error);  // connection errors dominate
+    if (!error_.ok() || min_progress_size_ > 0) {
+      if (error.connection_error() && !error_.connection_error()) {
+        error_ = std::move(error);  // connection errors dominate
       }
       return;
     }
-    error = std::move(new_error);
+    error_ = std::move(error);
   }
 
   // Refcount if we are backed by a slice
@@ -328,8 +320,7 @@ class HPackParser::Input {
   // Frontier denotes the first byte past successfully processed input
   const uint8_t* frontier_;
   // Current error
-  HpackParseResult& frame_error_;
-  HpackParseResult& field_error_;
+  HpackParseResult& error_;
   // If the error was EOF, we flag it here by noting how many more bytes would
   // be needed to make progress
   size_t min_progress_size_ = 0;
@@ -606,7 +597,6 @@ class HPackParser::Parser {
   bool ParseTop() {
     GPR_DEBUG_ASSERT(state_.parse_state == ParseState::kTop);
     auto cur = *input_->Next();
-    input_->ClearFieldError();
     switch (cur >> 4) {
         // Literal header not indexed - First byte format: 0000xxxx
         // Literal header never indexed - First byte format: 0001xxxx
@@ -712,7 +702,7 @@ class HPackParser::Parser {
         break;
     }
     gpr_log(
-        GPR_INFO, "HTTP:%d:%s:%s: %s%s", log_info_.stream_id, type,
+        GPR_DEBUG, "HTTP:%d:%s:%s: %s%s", log_info_.stream_id, type,
         log_info_.is_client ? "CLI" : "SVR", memento.md.DebugString().c_str(),
         memento.parse_status == nullptr
             ? ""
@@ -961,10 +951,11 @@ class HPackParser::Parser {
                                   state_.string_length)
             : String::Parse(input_, state_.is_string_huff_compressed,
                             state_.string_length);
+    HpackParseResult& status = state_.frame_error;
     absl::string_view key_string;
     if (auto* s = absl::get_if<Slice>(&state_.key)) {
       key_string = s->as_string_view();
-      if (state_.field_error.ok()) {
+      if (status.ok()) {
         auto r = ValidateKey(key_string);
         if (r != ValidateMetadataResult::kOk) {
           input_->SetErrorAndContinueParsing(
@@ -974,7 +965,7 @@ class HPackParser::Parser {
     } else {
       const auto* memento = absl::get<const HPackTable::Memento*>(state_.key);
       key_string = memento->md.key();
-      if (state_.field_error.ok() && memento->parse_status != nullptr) {
+      if (status.ok() && memento->parse_status != nullptr) {
         input_->SetErrorAndContinueParsing(*memento->parse_status);
       }
     }
@@ -1001,16 +992,16 @@ class HPackParser::Parser {
         key_string.size() + value.wire_size + hpack_constants::kEntryOverhead;
     auto md = grpc_metadata_batch::Parse(
         key_string, std::move(value_slice), state_.add_to_table, transport_size,
-        [key_string, this](absl::string_view message, const Slice&) {
-          if (!state_.field_error.ok()) return;
+        [key_string, &status, this](absl::string_view message, const Slice&) {
+          if (!status.ok()) return;
           input_->SetErrorAndContinueParsing(
               HpackParseResult::MetadataParseError(key_string));
           gpr_log(GPR_ERROR, "Error parsing '%s' metadata: %s",
                   std::string(key_string).c_str(),
                   std::string(message).c_str());
         });
-    HPackTable::Memento memento{
-        std::move(md), state_.field_error.PersistentStreamErrorOrNullptr()};
+    HPackTable::Memento memento{std::move(md),
+                                status.PersistentStreamErrorOrNullptr()};
     input_->UpdateFrontier();
     state_.parse_state = ParseState::kTop;
     if (state_.add_to_table) {
@@ -1172,13 +1163,13 @@ grpc_error_handle HPackParser::Parse(
     std::vector<uint8_t> buffer = std::move(unparsed_bytes_);
     return ParseInput(
         Input(nullptr, buffer.data(), buffer.data() + buffer.size(), bitsrc,
-              state_.frame_error, state_.field_error),
+              state_.frame_error),
         is_last, call_tracer);
   }
-  return ParseInput(Input(slice.refcount, GRPC_SLICE_START_PTR(slice),
-                          GRPC_SLICE_END_PTR(slice), bitsrc, state_.frame_error,
-                          state_.field_error),
-                    is_last, call_tracer);
+  return ParseInput(
+      Input(slice.refcount, GRPC_SLICE_START_PTR(slice),
+            GRPC_SLICE_END_PTR(slice), bitsrc, state_.frame_error),
+      is_last, call_tracer);
 }
 
 grpc_error_handle HPackParser::ParseInput(

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

@@ -236,8 +236,6 @@ class HPackParser {
     HPackTable hpack_table;
     // Error so far for this frame (set by class Input)
     HpackParseResult frame_error;
-    // Error so far for this field (set by class Input)
-    HpackParseResult field_error;
     // Length of frame so far.
     uint32_t frame_length = 0;
     // Length of the string being parsed