grpc 1.71.0 → 1.72.0

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

@@ -42,7 +42,7 @@ class ContextListEntry {
   ContextListEntry(void* context, int64_t outbuf_offset,
                    int64_t num_traced_bytes, size_t byte_offset,
                    size_t stream_index,
-                   std::shared_ptr<TcpTracerInterface> tcp_tracer)
+                   std::shared_ptr<TcpCallTracer> tcp_tracer)
       : trace_context_(context),
         outbuf_offset_(outbuf_offset),
         num_traced_bytes_in_chunk_(num_traced_bytes),
@@ -57,7 +57,7 @@ class ContextListEntry {
   int64_t NumTracedBytesInChunk() { return num_traced_bytes_in_chunk_; }
   size_t ByteOffsetInStream() { return byte_offset_in_stream_; }
   size_t StreamIndex() { return stream_index_; }
-  std::shared_ptr<TcpTracerInterface> ReleaseTcpTracer() {
+  std::shared_ptr<TcpCallTracer> ReleaseTcpTracer() {
     return std::move(tcp_tracer_);
   }
 
@@ -72,7 +72,7 @@ class ContextListEntry {
   // Index of the current chunk in the RPC stream.
   // Set to zero for the first chunk of the RPC stream.
   size_t stream_index_;
-  std::shared_ptr<TcpTracerInterface> tcp_tracer_;
+  std::shared_ptr<TcpCallTracer> tcp_tracer_;
 };
 
 /// A list of RPC Contexts

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

@@ -18,27 +18,33 @@
 #include <stddef.h>
 
 #include <cstdint>
+#include <string>
 #include <utility>
 
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
+#include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/util/crash.h"
 
 namespace grpc_core {
 
 namespace {
 
-constexpr uint8_t kFrameTypeData = 0;
-constexpr uint8_t kFrameTypeHeader = 1;
-constexpr uint8_t kFrameTypeContinuation = 9;
-constexpr uint8_t kFrameTypeRstStream = 3;
-constexpr uint8_t kFrameTypeSettings = 4;
-constexpr uint8_t kFrameTypePing = 6;
-constexpr uint8_t kFrameTypeGoaway = 7;
-constexpr uint8_t kFrameTypeWindowUpdate = 8;
-constexpr uint8_t kFrameTypePushPromise = 5;
-constexpr uint8_t kFrameTypeSecurity = 200;
+// HTTP2 Frame Types
+enum class FrameType : uint8_t {
+  kData = 0,
+  kHeader = 1,
+  // type 2 was Priority which has been deprecated.
+  kRstStream = 3,
+  kSettings = 4,
+  kPushPromise = 5,
+  kPing = 6,
+  kGoaway = 7,
+  kWindowUpdate = 8,
+  kContinuation = 9,
+  kCustomSecurity = 200,  // Custom Frame Type
+};
 
 constexpr uint8_t kFlagEndStream = 1;
 constexpr uint8_t kFlagAck = 1;
@@ -46,8 +52,6 @@ constexpr uint8_t kFlagEndHeaders = 4;
 constexpr uint8_t kFlagPadded = 8;
 constexpr uint8_t kFlagPriority = 0x20;
 
-constexpr size_t kFrameHeaderSize = 9;
-
 void Write2b(uint16_t x, uint8_t* output) {
   output[0] = static_cast<uint8_t>(x >> 8);
   output[1] = static_cast<uint8_t>(x);
@@ -125,6 +129,7 @@ class SerializeExtraBytesRequired {
   size_t operator()(const Http2WindowUpdateFrame&) { return 4; }
   size_t operator()(const Http2SecurityFrame&) { return 0; }
   size_t operator()(const Http2UnknownFrame&) { Crash("unreachable"); }
+  size_t operator()(const Http2EmptyFrame&) { Crash("unreachable"); }
 };
 
 class SerializeHeaderAndPayload {
@@ -135,9 +140,10 @@ class SerializeHeaderAndPayload {
 
   void operator()(Http2DataFrame& frame) {
     auto hdr = extra_bytes_.TakeFirst(kFrameHeaderSize);
-    Http2FrameHeader{
-        static_cast<uint32_t>(frame.payload.Length()), kFrameTypeData,
-        MaybeFlag(frame.end_stream, kFlagEndStream), frame.stream_id}
+    Http2FrameHeader{static_cast<uint32_t>(frame.payload.Length()),
+                     static_cast<uint8_t>(FrameType::kData),
+                     MaybeFlag(frame.end_stream, kFlagEndStream),
+                     frame.stream_id}
         .Serialize(hdr.begin());
     out_.AppendIndexed(Slice(std::move(hdr)));
     out_.TakeAndAppend(frame.payload);
@@ -146,7 +152,8 @@ class SerializeHeaderAndPayload {
   void operator()(Http2HeaderFrame& frame) {
     auto hdr = extra_bytes_.TakeFirst(kFrameHeaderSize);
     Http2FrameHeader{
-        static_cast<uint32_t>(frame.payload.Length()), kFrameTypeHeader,
+        static_cast<uint32_t>(frame.payload.Length()),
+        static_cast<uint8_t>(FrameType::kHeader),
         static_cast<uint8_t>(MaybeFlag(frame.end_headers, kFlagEndHeaders) |
                              MaybeFlag(frame.end_stream, kFlagEndStream)),
         frame.stream_id}
@@ -158,7 +165,8 @@ class SerializeHeaderAndPayload {
   void operator()(Http2ContinuationFrame& frame) {
     auto hdr = extra_bytes_.TakeFirst(kFrameHeaderSize);
     Http2FrameHeader{
-        static_cast<uint32_t>(frame.payload.Length()), kFrameTypeContinuation,
+        static_cast<uint32_t>(frame.payload.Length()),
+        static_cast<uint8_t>(FrameType::kContinuation),
         static_cast<uint8_t>(MaybeFlag(frame.end_headers, kFlagEndHeaders)),
         frame.stream_id}
         .Serialize(hdr.begin());
@@ -168,8 +176,9 @@ class SerializeHeaderAndPayload {
 
   void operator()(Http2RstStreamFrame& frame) {
     auto hdr_and_payload = extra_bytes_.TakeFirst(kFrameHeaderSize + 4);
-    Http2FrameHeader{4, kFrameTypeRstStream, 0, frame.stream_id}.Serialize(
-        hdr_and_payload.begin());
+    Http2FrameHeader{4, static_cast<uint8_t>(FrameType::kRstStream), 0,
+                     frame.stream_id}
+        .Serialize(hdr_and_payload.begin());
     Write4b(frame.error_code, hdr_and_payload.begin() + kFrameHeaderSize);
     out_.AppendIndexed(Slice(std::move(hdr_and_payload)));
   }
@@ -179,7 +188,8 @@ class SerializeHeaderAndPayload {
     const size_t payload_size = 6 * frame.settings.size();
     auto hdr_and_payload =
         extra_bytes_.TakeFirst(kFrameHeaderSize + payload_size);
-    Http2FrameHeader{static_cast<uint32_t>(payload_size), kFrameTypeSettings,
+    Http2FrameHeader{static_cast<uint32_t>(payload_size),
+                     static_cast<uint8_t>(FrameType::kSettings),
                      MaybeFlag(frame.ack, kFlagAck), 0}
         .Serialize(hdr_and_payload.begin());
     size_t offset = kFrameHeaderSize;
@@ -193,7 +203,8 @@ class SerializeHeaderAndPayload {
 
   void operator()(Http2PingFrame& frame) {
     auto hdr_and_payload = extra_bytes_.TakeFirst(kFrameHeaderSize + 8);
-    Http2FrameHeader{8, kFrameTypePing, MaybeFlag(frame.ack, kFlagAck), 0}
+    Http2FrameHeader{8, static_cast<uint8_t>(FrameType::kPing),
+                     MaybeFlag(frame.ack, kFlagAck), 0}
         .Serialize(hdr_and_payload.begin());
     Write8b(frame.opaque, hdr_and_payload.begin() + kFrameHeaderSize);
     out_.AppendIndexed(Slice(std::move(hdr_and_payload)));
@@ -202,7 +213,7 @@ class SerializeHeaderAndPayload {
   void operator()(Http2GoawayFrame& frame) {
     auto hdr_and_fixed_payload = extra_bytes_.TakeFirst(kFrameHeaderSize + 8);
     Http2FrameHeader{static_cast<uint32_t>(8 + frame.debug_data.length()),
-                     kFrameTypeGoaway, 0, 0}
+                     static_cast<uint8_t>(FrameType::kGoaway), 0, 0}
         .Serialize(hdr_and_fixed_payload.begin());
     Write4b(frame.last_stream_id,
             hdr_and_fixed_payload.begin() + kFrameHeaderSize);
@@ -214,8 +225,9 @@ class SerializeHeaderAndPayload {
 
   void operator()(Http2WindowUpdateFrame& frame) {
     auto hdr_and_payload = extra_bytes_.TakeFirst(kFrameHeaderSize + 4);
-    Http2FrameHeader{4, kFrameTypeWindowUpdate, 0, frame.stream_id}.Serialize(
-        hdr_and_payload.begin());
+    Http2FrameHeader{4, static_cast<uint8_t>(FrameType::kWindowUpdate), 0,
+                     frame.stream_id}
+        .Serialize(hdr_and_payload.begin());
     Write4b(frame.increment, hdr_and_payload.begin() + kFrameHeaderSize);
     out_.AppendIndexed(Slice(std::move(hdr_and_payload)));
   }
@@ -223,7 +235,7 @@ class SerializeHeaderAndPayload {
   void operator()(Http2SecurityFrame& frame) {
     auto hdr = extra_bytes_.TakeFirst(kFrameHeaderSize);
     Http2FrameHeader{static_cast<uint32_t>(frame.payload.Length()),
-                     kFrameTypeSecurity, 0, 0}
+                     static_cast<uint8_t>(FrameType::kCustomSecurity), 0, 0}
         .Serialize(hdr.begin());
     out_.AppendIndexed(Slice(std::move(hdr)));
     out_.TakeAndAppend(frame.payload);
@@ -231,6 +243,8 @@ class SerializeHeaderAndPayload {
 
   void operator()(Http2UnknownFrame&) { Crash("unreachable"); }
 
+  void operator()(Http2EmptyFrame&) {}
+
  private:
   SliceBuffer& out_;
   MutableSlice extra_bytes_;
@@ -365,18 +379,9 @@ absl::StatusOr<Http2PingFrame> ParsePingFrame(const Http2FrameHeader& hdr,
         absl::StrCat("invalid ping stream id: ", hdr.ToString()));
   }
 
-  bool ack;
-  switch (hdr.flags) {
-    case 0:
-      ack = false;
-      break;
-    case kFlagAck:
-      ack = true;
-      break;
-    default:
-      return absl::InternalError(
-          absl::StrCat("invalid ping flags: ", hdr.ToString()));
-  }
+  // RFC9113 : Unused flags MUST be ignored on receipt and MUST be left unset
+  // (0x00) when sending.
+  bool ack = ((hdr.flags & kFlagAck) == kFlagAck);
 
   uint8_t buffer[8];
   payload.CopyToBuffer(buffer);
@@ -397,11 +402,6 @@ absl::StatusOr<Http2GoawayFrame> ParseGoawayFrame(const Http2FrameHeader& hdr,
         absl::StrCat("invalid goaway stream id: ", hdr.ToString()));
   }
 
-  if (hdr.flags != 0) {
-    return absl::InternalError(
-        absl::StrCat("invalid goaway flags: ", hdr.ToString()));
-  }
-
   uint8_t buffer[8];
   payload.MoveFirstNBytesIntoBuffer(8, buffer);
   return Http2GoawayFrame{Read4b(buffer), Read4b(buffer + 4),
@@ -445,34 +445,38 @@ Http2FrameHeader Http2FrameHeader::Parse(const uint8_t* input) {
 }
 
 namespace {
-std::string Http2FrameTypeString(uint8_t frame_type) {
+
+std::string Http2FrameTypeString(FrameType frame_type) {
   switch (frame_type) {
-    case kFrameTypeData:
+    case FrameType::kData:
       return "DATA";
-    case kFrameTypeHeader:
+    case FrameType::kHeader:
       return "HEADER";
-    case kFrameTypeContinuation:
-      return "CONTINUATION";
-    case kFrameTypeRstStream:
+    case FrameType::kRstStream:
       return "RST_STREAM";
-    case kFrameTypeSettings:
+    case FrameType::kSettings:
       return "SETTINGS";
-    case kFrameTypeGoaway:
+    case FrameType::kPushPromise:
+      return "PUSH_PROMISE";
+    case FrameType::kPing:
+      return "PING";
+    case FrameType::kGoaway:
       return "GOAWAY";
-    case kFrameTypeWindowUpdate:
+    case FrameType::kWindowUpdate:
       return "WINDOW_UPDATE";
-    case kFrameTypePing:
-      return "PING";
-    case kFrameTypeSecurity:
+    case FrameType::kContinuation:
+      return "CONTINUATION";
+    case FrameType::kCustomSecurity:
       return "SECURITY";
   }
-  return absl::StrCat("UNKNOWN(", frame_type, ")");
+  return absl::StrCat("UNKNOWN(", static_cast<uint8_t>(frame_type), ")");
 }
 }  // namespace
 
 std::string Http2FrameHeader::ToString() const {
-  return absl::StrCat("{", Http2FrameTypeString(type), ": flags=", flags,
-                      ", stream_id=", stream_id, ", length=", length, "}");
+  return absl::StrCat("{", Http2FrameTypeString(static_cast<FrameType>(type)),
+                      ": flags=", flags, ", stream_id=", stream_id,
+                      ", length=", length, "}");
 }
 
 void Serialize(absl::Span<Http2Frame> frames, SliceBuffer& out) {
@@ -492,32 +496,49 @@ void Serialize(absl::Span<Http2Frame> frames, SliceBuffer& out) {
 absl::StatusOr<Http2Frame> ParseFramePayload(const Http2FrameHeader& hdr,
                                              SliceBuffer payload) {
   CHECK(payload.Length() == hdr.length);
-  switch (hdr.type) {
-    case kFrameTypeData:
+  switch (static_cast<FrameType>(hdr.type)) {
+    case FrameType::kData:
       return ParseDataFrame(hdr, payload);
-    case kFrameTypeHeader:
+    case FrameType::kHeader:
       return ParseHeaderFrame(hdr, payload);
-    case kFrameTypeContinuation:
+    case FrameType::kContinuation:
       return ParseContinuationFrame(hdr, payload);
-    case kFrameTypeRstStream:
+    case FrameType::kRstStream:
       return ParseRstStreamFrame(hdr, payload);
-    case kFrameTypeSettings:
+    case FrameType::kSettings:
       return ParseSettingsFrame(hdr, payload);
-    case kFrameTypePing:
+    case FrameType::kPing:
       return ParsePingFrame(hdr, payload);
-    case kFrameTypeGoaway:
+    case FrameType::kGoaway:
       return ParseGoawayFrame(hdr, payload);
-    case kFrameTypeWindowUpdate:
+    case FrameType::kWindowUpdate:
       return ParseWindowUpdateFrame(hdr, payload);
-    case kFrameTypePushPromise:
+    case FrameType::kPushPromise:
       return absl::InternalError(
           "push promise not supported (and SETTINGS_ENABLE_PUSH explicitly "
           "disabled).");
-    case kFrameTypeSecurity:
+    case FrameType::kCustomSecurity:
       return ParseSecurityFrame(hdr, payload);
     default:
       return Http2UnknownFrame{};
   }
 }
 
+GrpcMessageHeader ExtractGrpcHeader(SliceBuffer& payload) {
+  CHECK_GE(payload.Length(), kGrpcHeaderSizeInBytes);
+  uint8_t buffer[kGrpcHeaderSizeInBytes];
+  payload.MoveFirstNBytesIntoBuffer(kGrpcHeaderSizeInBytes, buffer);
+  GrpcMessageHeader header;
+  header.flags = buffer[0];
+  header.length = Read4b(buffer + 1);
+  return header;
+}
+
+void AppendGrpcHeaderToSliceBuffer(SliceBuffer& payload, const uint8_t flags,
+                                   const uint32_t length) {
+  uint8_t* frame_hdr = payload.AddTiny(kGrpcHeaderSizeInBytes);
+  frame_hdr[0] = flags;
+  Write4b(length, frame_hdr + 1);
+}
+
 }  // namespace grpc_core

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

@@ -50,6 +50,19 @@ namespace grpc_core {
 //
 // Equality operators are defined for use in unit tests.
 
+// All frames begin with a fixed 9-octet header followed by a variable-length
+// frame payload. The following sizes are in bits.
+// HTTP Frame {
+//   Length(24),
+//   Type(8),
+//   Flags(8),
+//   Reserved(1),
+//   Stream Identifier(31),
+//   Frame Payload(..),
+// }
+// Reference : https://www.rfc-editor.org/rfc/rfc9113.html#name-frame-format
+constexpr uint8_t kFrameHeaderSize = 9;
+
 // DATA frame
 struct Http2DataFrame {
   uint32_t stream_id = 0;
@@ -165,6 +178,11 @@ struct Http2UnknownFrame {
   bool operator==(const Http2UnknownFrame&) const { return true; }
 };
 
+// This is used as a fake frame to trigger events in the HTTP2 transport.
+struct Http2EmptyFrame {
+  bool operator==(const Http2EmptyFrame&) const { return true; }
+};
+
 ///////////////////////////////////////////////////////////////////////////////
 // Frame variant
 //
@@ -174,7 +192,7 @@ using Http2Frame =
     std::variant<Http2DataFrame, Http2HeaderFrame, Http2ContinuationFrame,
                  Http2RstStreamFrame, Http2SettingsFrame, Http2PingFrame,
                  Http2GoawayFrame, Http2WindowUpdateFrame, Http2SecurityFrame,
-                 Http2UnknownFrame>;
+                 Http2UnknownFrame, Http2EmptyFrame>;
 
 ///////////////////////////////////////////////////////////////////////////////
 // Frame header
@@ -218,6 +236,24 @@ absl::StatusOr<Http2Frame> ParseFramePayload(const Http2FrameHeader& hdr,
 // move things out of frames)
 void Serialize(absl::Span<Http2Frame> frames, SliceBuffer& out);
 
+///////////////////////////////////////////////////////////////////////////////
+// GRPC Header
+
+constexpr uint8_t kGrpcHeaderSizeInBytes = 5;
+
+struct GrpcMessageHeader {
+  uint8_t flags;
+  uint32_t length;
+};
+
+// If the payload SliceBuffer is too small to hold a gRPC header, this function
+// will crash. The calling function MUST ensure that the payload SliceBuffer
+// has length greater than or equal to the gRPC header.
+GrpcMessageHeader ExtractGrpcHeader(SliceBuffer& payload);
+
+void AppendGrpcHeaderToSliceBuffer(SliceBuffer& payload, const uint8_t flags,
+                                   const uint32_t length);
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_FRAME_H

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

@@ -31,6 +31,7 @@
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/telemetry/stats.h"
 #include "src/core/util/status_helper.h"
 
 absl::Status grpc_chttp2_data_parser_begin_frame(uint8_t flags,
@@ -75,6 +76,7 @@ void grpc_chttp2_encode_data(uint32_t id, grpc_slice_buffer* inbuf,
 
   grpc_slice_buffer_move_first_no_ref(inbuf, write_bytes, outbuf);
 
+  grpc_core::global_stats().IncrementHttp2WriteDataFrameSize(write_bytes);
   call_tracer->RecordOutgoingBytes({header_size, 0, 0});
 }
 

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

@@ -28,16 +28,18 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/ext/transport/chttp2/transport/call_tracer_wrapper.h"
+#include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/ext/transport/chttp2/transport/ping_callbacks.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
-#include "src/core/lib/transport/http2_errors.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/util/status_helper.h"
 
+using grpc_core::http2::Http2ErrorCode;
+
 grpc_slice grpc_chttp2_rst_stream_create(
     uint32_t id, uint32_t code, grpc_core::CallTracerInterface* call_tracer) {
   static const size_t frame_size = 13;
@@ -116,7 +118,8 @@ grpc_error_handle grpc_chttp2_rst_stream_parser_parse(void* parser,
         << "[chttp2 transport=" << t << " stream=" << s
         << "] received RST_STREAM(reason=" << reason << ")";
     grpc_error_handle error;
-    if (reason != GRPC_HTTP2_NO_ERROR || s->trailing_metadata_buffer.empty()) {
+    if (reason != static_cast<uint32_t>(Http2ErrorCode::kNoError) ||
+        s->trailing_metadata_buffer.empty()) {
       error = grpc_error_set_int(
           grpc_error_set_str(
               GRPC_ERROR_CREATE("RST_STREAM"),

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

@@ -40,6 +40,8 @@
 #include "src/core/util/debug_location.h"
 #include "src/core/util/useful.h"
 
+using grpc_core::http2::Http2ErrorCode;
+
 static uint8_t* fill_header(uint8_t* out, uint32_t length, uint8_t flags) {
   *out++ = static_cast<uint8_t>(length >> 16);
   *out++ = static_cast<uint8_t>(length >> 8);
@@ -193,9 +195,9 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
         }
         auto error =
             parser->incoming_settings->Apply(parser->id, parser->value);
-        if (error != GRPC_HTTP2_NO_ERROR) {
+        if (error != Http2ErrorCode::kNoError) {
           grpc_chttp2_goaway_append(
-              t->last_new_stream_id, error,
+              t->last_new_stream_id, static_cast<uint32_t>(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,

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

@@ -31,12 +31,12 @@
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "src/core/call/metadata_batch.h"
+#include "src/core/call/metadata_compression_traits.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder_table.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
-#include "src/core/lib/transport/metadata_batch.h"
-#include "src/core/lib/transport/metadata_compression_traits.h"
 #include "src/core/lib/transport/timeout_encoding.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/telemetry/call_tracer.h"

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

@@ -27,8 +27,8 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/lib/surface/validate_metadata.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"

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

@@ -38,6 +38,8 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
+#include "src/core/call/metadata_info.h"
+#include "src/core/call/parsed_metadata.h"
 #include "src/core/ext/transport/chttp2/transport/decode_huff.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parse_result.h"
@@ -46,8 +48,6 @@
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_refcount.h"
 #include "src/core/lib/surface/validate_metadata.h"
-#include "src/core/lib/transport/metadata_info.h"
-#include "src/core/lib/transport/parsed_metadata.h"
 #include "src/core/telemetry/call_tracer.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"

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

@@ -34,13 +34,13 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parse_result.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parser_table.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_refcount.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/telemetry/call_tracer.h"
 #include "src/core/util/random_early_detection.h"
 

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

@@ -29,10 +29,10 @@
 #include <vector>
 
 #include "absl/functional/function_ref.h"
+#include "src/core/call/metadata_batch.h"
+#include "src/core/call/parsed_metadata.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parse_result.h"
-#include "src/core/lib/transport/metadata_batch.h"
-#include "src/core/lib/transport/parsed_metadata.h"
 #include "src/core/util/no_destruct.h"
 #include "src/core/util/unique_ptr_with_bitset.h"
 

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

@@ -24,9 +24,11 @@
 
 #include "absl/strings/str_cat.h"
 #include "src/core/ext/transport/chttp2/transport/frame.h"
-#include "src/core/lib/transport/http2_errors.h"
+#include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/util/useful.h"
 
+using grpc_core::http2::Http2ErrorCode;
+
 namespace grpc_core {
 
 void Http2Settings::Diff(
@@ -88,13 +90,13 @@ std::string Http2Settings::WireIdToName(uint16_t wire_id) {
   }
 }
 
-grpc_http2_error_code Http2Settings::Apply(uint16_t key, uint32_t value) {
+Http2ErrorCode Http2Settings::Apply(uint16_t key, uint32_t value) {
   switch (key) {
     case kHeaderTableSizeWireId:
       header_table_size_ = value;
       break;
     case kEnablePushWireId:
-      if (value > 1) return GRPC_HTTP2_PROTOCOL_ERROR;
+      if (value > 1) return Http2ErrorCode::kProtocolError;
       enable_push_ = value != 0;
       break;
     case kMaxConcurrentStreamsWireId:
@@ -102,13 +104,13 @@ grpc_http2_error_code Http2Settings::Apply(uint16_t key, uint32_t value) {
       break;
     case kInitialWindowSizeWireId:
       if (value > max_initial_window_size()) {
-        return GRPC_HTTP2_FLOW_CONTROL_ERROR;
+        return Http2ErrorCode::kFlowControlError;
       }
       initial_window_size_ = value;
       break;
     case kMaxFrameSizeWireId:
       if (value < min_max_frame_size() || value > max_max_frame_size()) {
-        return GRPC_HTTP2_PROTOCOL_ERROR;
+        return Http2ErrorCode::kProtocolError;
       }
       max_frame_size_ = value;
       break;
@@ -116,7 +118,7 @@ grpc_http2_error_code Http2Settings::Apply(uint16_t key, uint32_t value) {
       max_header_list_size_ = std::min(value, 16777216u);
       break;
     case kGrpcAllowTrueBinaryMetadataWireId:
-      if (value > 1) return GRPC_HTTP2_PROTOCOL_ERROR;
+      if (value > 1) return Http2ErrorCode::kProtocolError;
       allow_true_binary_metadata_ = value != 0;
       break;
     case kGrpcPreferredReceiveCryptoFrameSizeWireId:
@@ -125,11 +127,11 @@ grpc_http2_error_code Http2Settings::Apply(uint16_t key, uint32_t value) {
                 max_preferred_receive_crypto_message_size());
       break;
     case kGrpcAllowSecurityFrameWireId:
-      if (value > 1) return GRPC_HTTP2_PROTOCOL_ERROR;
+      if (value > 1) return Http2ErrorCode::kProtocolError;
       allow_security_frame_ = value != 0;
       break;
   }
-  return GRPC_HTTP2_NO_ERROR;
+  return Http2ErrorCode::kNoError;
 }
 
 std::optional<Http2SettingsFrame> Http2SettingsManager::MaybeSendUpdate() {

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

@@ -26,7 +26,7 @@
 #include "absl/functional/function_ref.h"
 #include "absl/strings/string_view.h"
 #include "src/core/ext/transport/chttp2/transport/frame.h"
-#include "src/core/lib/transport/http2_errors.h"
+#include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/util/useful.h"
 
 namespace grpc_core {
@@ -47,7 +47,7 @@ class Http2Settings {
 
   void Diff(bool is_first_send, const Http2Settings& old,
             absl::FunctionRef<void(uint16_t key, uint32_t value)> cb) const;
-  GRPC_MUST_USE_RESULT grpc_http2_error_code Apply(uint16_t key,
+  GRPC_MUST_USE_RESULT http2::Http2ErrorCode Apply(uint16_t key,
                                                    uint32_t value);
   uint32_t header_table_size() const { return header_table_size_; }
   uint32_t max_concurrent_streams() const { return max_concurrent_streams_; }