grpc 1.50.0.pre1 → 1.52.0.pre2

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

@@ -1,20 +1,20 @@
-/*
- *
- * 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.
- *
- */
+//
+//
+// 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_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_H
 #define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_H
@@ -30,22 +30,20 @@
 #include "absl/strings/match.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/impl/codegen/compression_types.h>
+#include <grpc/impl/compression_types.h>
 #include <grpc/slice.h>
 #include <grpc/status.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/compression/compression_internal.h"
-#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/time.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/timeout_encoding.h"
 #include "src/core/lib/transport/transport.h"
 
-extern grpc_core::TraceFlag grpc_http_trace;
-
 namespace grpc_core {
 
 class HPackCompressor {
@@ -76,18 +74,23 @@ class HPackCompressor {
   template <typename HeaderSet>
   void EncodeHeaders(const EncodeHeaderOptions& options,
                      const HeaderSet& headers, grpc_slice_buffer* output) {
-    Framer framer(options, this, output);
-    headers.Encode(&framer);
+    SliceBuffer raw;
+    Encoder encoder(this, options.use_true_binary_metadata, raw);
+    headers.Encode(&encoder);
+    Frame(options, raw, output);
   }
 
-  class Framer {
-   public:
-    Framer(const EncodeHeaderOptions& options, HPackCompressor* compressor,
-           grpc_slice_buffer* output);
-    ~Framer() { FinishFrame(true); }
+  template <typename HeaderSet>
+  void EncodeRawHeaders(const HeaderSet& headers, SliceBuffer& output) {
+    Encoder encoder(this, true, output);
+    headers.Encode(&encoder);
+  }
 
-    Framer(const Framer&) = delete;
-    Framer& operator=(const Framer&) = delete;
+ private:
+  class Encoder {
+   public:
+    Encoder(HPackCompressor* compressor, bool use_true_binary_metadata,
+            SliceBuffer& output);
 
     void Encode(const Slice& key, const Slice& value);
     void Encode(HttpPathMetadata, const Slice& value);
@@ -124,18 +127,6 @@ class HPackCompressor {
    private:
     friend class SliceIndex;
 
-    struct FramePrefix {
-      // index (in output_) of the header for the frame
-      size_t header_idx;
-      // number of bytes in 'output' when we started the frame - used to
-      // calculate frame length
-      size_t output_length_at_start_of_frame;
-    };
-
-    FramePrefix BeginFrame();
-    void FinishFrame(bool is_header_boundary);
-    void EnsureSpace(size_t need_bytes);
-
     void AdvertiseTableSizeChange();
     void EmitIndexed(uint32_t index);
     void EmitLitHdrWithNonBinaryStringKeyIncIdx(Slice key_slice,
@@ -150,7 +141,7 @@ class HPackCompressor {
                                                 Slice value_slice);
 
     void EncodeAlwaysIndexed(uint32_t* index, absl::string_view key,
-                             Slice value, uint32_t transport_length);
+                             Slice value, size_t transport_length);
     void EncodeIndexedKeyWithBinaryValue(uint32_t* index, absl::string_view key,
                                          Slice value);
 
@@ -158,27 +149,17 @@ class HPackCompressor {
                                    const Slice& slice, uint32_t* index,
                                    size_t max_compression_size);
 
-    size_t CurrentFrameSize() const;
-    void Add(Slice slice);
-    uint8_t* AddTiny(size_t len);
-
-    // maximum size of a frame
-    const size_t max_frame_size_;
-    bool is_first_frame_ = true;
     const bool use_true_binary_metadata_;
-    const bool is_end_of_stream_;
-    // output stream id
-    const uint32_t stream_id_;
-    grpc_slice_buffer* const output_;
-    grpc_transport_one_way_stats* const stats_;
     HPackCompressor* const compressor_;
-    FramePrefix prefix_;
+    SliceBuffer& output_;
   };
 
- private:
   static constexpr size_t kNumFilterValues = 64;
   static constexpr uint32_t kNumCachedGrpcStatusValues = 16;
 
+  void Frame(const EncodeHeaderOptions& options, SliceBuffer& raw,
+             grpc_slice_buffer* output);
+
   // maximum number of bytes we'll use for the decode table (to guard against
   // peers ooming us by setting decode table size high)
   uint32_t max_usable_size_ = hpack_constants::kInitialTableSize;
@@ -189,7 +170,7 @@ class HPackCompressor {
 
   class SliceIndex {
    public:
-    void EmitTo(absl::string_view key, const Slice& value, Framer* framer);
+    void EmitTo(absl::string_view key, const Slice& value, Encoder* encoder);
 
    private:
     struct ValueIndex {
@@ -233,4 +214,4 @@ class HPackCompressor {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_H */
+#endif  // GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_H

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

@@ -60,7 +60,8 @@ bool HPackEncoderTable::SetMaxSize(uint32_t max_table_size) {
       hpack_constants::EntriesForBytes(max_table_size);
   // TODO(ctiller): integrate with ResourceQuota to rebuild smaller when we can.
   if (max_table_elems > elem_size_.size()) {
-    Rebuild(std::max(max_table_elems, 2 * elem_size_.size()));
+    Rebuild(static_cast<uint32_t>(
+        std::max(max_table_elems, 2 * elem_size_.size())));
   }
   return true;
 }

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

@@ -1,32 +1,30 @@
-/*
- *
- * 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.
- *
- */
+//
+//
+// 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.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/transport/chttp2/transport/hpack_parser.h"
 
 #include <assert.h>
-#include <inttypes.h>
 #include <stddef.h>
 #include <stdlib.h>
 
 #include <algorithm>
-#include <cstdint>
 #include <string>
 #include <utility>
 
@@ -44,18 +42,13 @@
 #include <grpc/support/log.h>
 
 #include "src/core/ext/transport/chttp2/transport/decode_huff.h"
-#include "src/core/ext/transport/chttp2/transport/frame_rst_stream.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
-#include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
-#include "src/core/lib/iomgr/closure.h"
-#include "src/core/lib/iomgr/combiner.h"
+#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/slice/slice.h"
-#include "src/core/lib/slice/slice_refcount_base.h"
-#include "src/core/lib/transport/http2_errors.h"
+#include "src/core/lib/slice/slice_refcount.h"
 #include "src/core/lib/transport/parsed_metadata.h"
-#include "src/core/lib/transport/transport.h"
 
 // IWYU pragma: no_include <type_traits>
 
@@ -63,12 +56,12 @@ namespace grpc_core {
 
 TraceFlag grpc_trace_chttp2_hpack_parser(false, "chttp2_hpack_parser");
 
-/* state table for huffman decoding: given a state, gives an index/16 into
-   next_sub_tbl. Taking that index and adding the value of the nibble being
-   considered returns the next state.
-   generated by gen_hpack_tables.c
-   TODO(ctiller): remove once the new_hpack_huffman_decoder experiment is
-                  complete. */
+// state table for huffman decoding: given a state, gives an index/16 into
+// next_sub_tbl. Taking that index and adding the value of the nibble being
+// considered returns the next state.
+// generated by gen_hpack_tables.c
+// TODO(ctiller): remove once the new_hpack_huffman_decoder experiment is
+//                complete.
 static const uint8_t next_tbl[256] = {
     0,  1,  2,  3,  4,  1,  2, 5,  6,  1, 7,  8,  1,  3,  3,  9,  10, 11, 1,  1,
     1,  12, 1,  2,  13, 1,  1, 1,  1,  1, 1,  1,  1,  1,  1,  1,  1,  1,  1,  2,
@@ -85,8 +78,8 @@ static const uint8_t next_tbl[256] = {
     3,  3,  3,  45, 46, 1,  1, 2,  2,  2, 35, 3,  3,  18, 47, 2,
 };
 
-/* next state, based upon current state and the current nibble: see above.
-   generated by gen_hpack_tables.c */
+// next state, based upon current state and the current nibble: see above.
+// generated by gen_hpack_tables.c
 static const int16_t next_sub_tbl[48 * 16] = {
     1,   204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217,
     218, 2,   6,   10,  13,  14,  15,  16,  17,  2,   6,   10,  13,  14,  15,
@@ -142,9 +135,9 @@ static const int16_t next_sub_tbl[48 * 16] = {
     0,   0,   255,
 };
 
-/* emission table: indexed like next_tbl, ultimately gives the byte to be
-   emitted, or -1 for no byte, or 256 for end of stream
-   generated by gen_hpack_tables.c */
+// emission table: indexed like next_tbl, ultimately gives the byte to be
+// emitted, or -1 for no byte, or 256 for end of stream
+// generated by gen_hpack_tables.c
 static const uint16_t emit_tbl[256] = {
     0,   1,   2,   3,   4,   5,   6,   7,   0,   8,   9,   10,  11,  12,  13,
     14,  15,  16,  17,  18,  19,  20,  21,  22,  0,   23,  24,  25,  26,  27,
@@ -166,7 +159,7 @@ static const uint16_t emit_tbl[256] = {
     248,
 };
 
-/* generated by gen_hpack_tables.c */
+// generated by gen_hpack_tables.c
 static const int16_t emit_sub_tbl[249 * 16] = {
     -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
     -1,  48,  48,  48,  48,  48,  48,  48,  48,  49,  49,  49,  49,  49,  49,
@@ -586,15 +579,14 @@ class HPackParser::Input {
   // Extract the parse error, leaving the current error as NONE.
   grpc_error_handle TakeError() {
     grpc_error_handle out = error_;
-    error_ = GRPC_ERROR_NONE;
+    error_ = absl::OkStatus();
     return out;
   }
 
   // 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 (!GRPC_ERROR_IS_NONE(error_) || eof_error_) {
-      GRPC_ERROR_UNREF(error);
+    if (!error_.ok() || eof_error_) {
       return;
     }
     error_ = error;
@@ -606,7 +598,7 @@ class HPackParser::Input {
   template <typename F, typename T>
   GPR_ATTRIBUTE_NOINLINE T MaybeSetErrorAndReturn(F error_factory,
                                                   T return_value) {
-    if (!GRPC_ERROR_IS_NONE(error_) || eof_error_) return return_value;
+    if (!error_.ok() || eof_error_) return return_value;
     error_ = error_factory();
     begin_ = end_;
     return return_value;
@@ -616,7 +608,7 @@ class HPackParser::Input {
   // is a common case)
   template <typename T>
   T UnexpectedEOF(T return_value) {
-    if (!GRPC_ERROR_IS_NONE(error_)) return return_value;
+    if (!error_.ok()) return return_value;
     eof_error_ = true;
     return return_value;
   }
@@ -633,7 +625,7 @@ class HPackParser::Input {
                                                  uint8_t last_byte) {
     return MaybeSetErrorAndReturn(
         [value, last_byte] {
-          return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
+          return GRPC_ERROR_CREATE(absl::StrFormat(
               "integer overflow in hpack integer decoding: have 0x%08x, "
               "got byte 0x%02x on byte 5",
               value, last_byte));
@@ -650,7 +642,7 @@ class HPackParser::Input {
   // Frontier denotes the first byte past successfully processed input
   const uint8_t* frontier_;
   // Current error
-  grpc_error_handle error_ = GRPC_ERROR_NONE;
+  grpc_error_handle error_;
   // If the error was EOF, we flag it here..
   bool eof_error_ = false;
 };
@@ -831,10 +823,7 @@ class HPackParser::String {
     }
     if (!result.has_value()) {
       return input->MaybeSetErrorAndReturn(
-          [] {
-            return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                "illegal base64 encoding");
-          },
+          [] { return GRPC_ERROR_CREATE("illegal base64 encoding"); },
           absl::optional<String>());
     }
     return String(std::move(*result));
@@ -1016,11 +1005,7 @@ class HPackParser::Parser {
         if (cur == 0x80) {
           // illegal value.
           return input_->MaybeSetErrorAndReturn(
-              [] {
-                return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                    "Illegal hpack op code");
-              },
-              false);
+              [] { return GRPC_ERROR_CREATE("Illegal hpack op code"); }, false);
         }
         ABSL_FALLTHROUGH_INTENDED;
       case 9:
@@ -1084,7 +1069,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(!GRPC_ERROR_IS_NONE(err))) {
+    if (GPR_UNLIKELY(!err.ok())) {
       input_->SetError(err);
       return false;
     };
@@ -1172,14 +1157,14 @@ class HPackParser::Parser {
     if (*dynamic_table_updates_allowed_ == 0) {
       return input_->MaybeSetErrorAndReturn(
           [] {
-            return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            return GRPC_ERROR_CREATE(
                 "More than two max table size changes in a single frame");
           },
           false);
     }
     (*dynamic_table_updates_allowed_)--;
     grpc_error_handle err = table_->SetCurrentTableSize(*size);
-    if (!GRPC_ERROR_IS_NONE(err)) {
+    if (!err.ok()) {
       input_->SetError(err);
       return false;
     }
@@ -1193,30 +1178,59 @@ class HPackParser::Parser {
     return input_->MaybeSetErrorAndReturn(
         [this, index] {
           return grpc_error_set_int(
-              grpc_error_set_int(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                                     "Invalid HPACK index received"),
-                                 GRPC_ERROR_INT_INDEX,
-                                 static_cast<intptr_t>(index)),
-              GRPC_ERROR_INT_SIZE,
+              grpc_error_set_int(
+                  GRPC_ERROR_CREATE("Invalid HPACK index received"),
+                  StatusIntProperty::kIndex, static_cast<intptr_t>(index)),
+              StatusIntProperty::kSize,
               static_cast<intptr_t>(this->table_->num_entries()));
         },
         std::move(result));
   }
 
+  class MetadataSizeLimitExceededEncoder {
+   public:
+    explicit MetadataSizeLimitExceededEncoder(std::string& summary)
+        : summary_(summary) {}
+
+    void Encode(const Slice& key, const Slice& value) {
+      AddToSummary(key.as_string_view(), value.size());
+    }
+
+    template <typename Key, typename Value>
+    void Encode(Key, const Value& value) {
+      AddToSummary(Key::key(), Key::Encode(value).size());
+    }
+
+   private:
+    void AddToSummary(absl::string_view key,
+                      size_t value_length) GPR_ATTRIBUTE_NOINLINE {
+      absl::StrAppend(&summary_, " ", key, ":",
+                      hpack_constants::SizeForEntry(key.size(), value_length),
+                      "B");
+    }
+    std::string& summary_;
+  };
+
   GPR_ATTRIBUTE_NOINLINE
-  bool HandleMetadataSizeLimitExceeded(const HPackTable::Memento&) {
-    gpr_log(GPR_DEBUG,
-            "received initial metadata size exceeds limit (%" PRIu32
-            " vs. %" PRIu32
-            "). GRPC_ARG_MAX_METADATA_SIZE can be set to increase this limit.",
-            *frame_length_, metadata_size_limit_);
+  bool HandleMetadataSizeLimitExceeded(const HPackTable::Memento& md) {
+    // Collect a summary of sizes so far for debugging
+    // Do not collect contents, for fear of exposing PII.
+    std::string summary;
+    if (metadata_buffer_ != nullptr) {
+      MetadataSizeLimitExceededEncoder encoder(summary);
+      metadata_buffer_->Encode(&encoder);
+    }
+    summary =
+        absl::StrCat("; adding ", md.key(), " (length ", md.transport_size(),
+                     "B)", summary.empty() ? "" : " to ", summary);
     if (metadata_buffer_ != nullptr) metadata_buffer_->Clear();
     return input_->MaybeSetErrorAndReturn(
-        [] {
+        [this, summary = std::move(summary)] {
           return grpc_error_set_int(
-              GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                  "received initial metadata size exceeds limit"),
-              GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_RESOURCE_EXHAUSTED);
+              GRPC_ERROR_CREATE(absl::StrCat(
+                  "received initial metadata size exceeds limit (",
+                  *frame_length_, " vs. ", metadata_size_limit_, ")", summary)),
+              StatusIntProperty::kRpcStatus, GRPC_STATUS_RESOURCE_EXHAUSTED);
         },
         false);
   }
@@ -1249,7 +1263,7 @@ Slice HPackParser::String::Take() {
   GPR_UNREACHABLE_CODE(return Slice());
 }
 
-/* PUBLIC INTERFACE */
+// PUBLIC INTERFACE
 
 HPackParser::HPackParser() = default;
 
@@ -1259,6 +1273,9 @@ void HPackParser::BeginFrame(grpc_metadata_batch* metadata_buffer,
                              uint32_t metadata_size_limit, Boundary boundary,
                              Priority priority, LogInfo log_info) {
   metadata_buffer_ = metadata_buffer;
+  if (metadata_buffer != nullptr) {
+    metadata_buffer->Set(GrpcStatusFromWire(), true);
+  }
   boundary_ = boundary;
   priority_ = priority;
   dynamic_table_updates_allowed_ = 2;
@@ -1282,15 +1299,15 @@ grpc_error_handle HPackParser::Parse(const grpc_slice& slice, bool is_last) {
 
 grpc_error_handle HPackParser::ParseInput(Input input, bool is_last) {
   if (ParseInputInner(&input)) {
-    return GRPC_ERROR_NONE;
+    return absl::OkStatus();
   }
   if (input.eof_error()) {
     if (GPR_UNLIKELY(is_last && is_boundary())) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+      return GRPC_ERROR_CREATE(
           "Incomplete header at the end of a header/continuation sequence");
     }
     unparsed_bytes_ = std::vector<uint8_t>(input.frontier(), input.end_ptr());
-    return GRPC_ERROR_NONE;
+    return absl::OkStatus();
   }
   return input.TakeError();
 }
@@ -1321,70 +1338,3 @@ bool HPackParser::ParseInputInner(Input* input) {
 void HPackParser::FinishFrame() { metadata_buffer_ = nullptr; }
 
 }  // namespace grpc_core
-
-// TODO(ctiller): this serves as an eviction notice for the remainder of this
-// file... it belongs elsewhere!
-
-typedef void (*maybe_complete_func_type)(grpc_chttp2_transport* t,
-                                         grpc_chttp2_stream* s);
-static const maybe_complete_func_type maybe_complete_funcs[] = {
-    grpc_chttp2_maybe_complete_recv_initial_metadata,
-    grpc_chttp2_maybe_complete_recv_trailing_metadata};
-
-static void force_client_rst_stream(void* sp, grpc_error_handle /*error*/) {
-  grpc_chttp2_stream* s = static_cast<grpc_chttp2_stream*>(sp);
-  grpc_chttp2_transport* t = s->t;
-  if (!s->write_closed) {
-    grpc_chttp2_add_rst_stream_to_next_write(t, s->id, GRPC_HTTP2_NO_ERROR,
-                                             &s->stats.outgoing);
-    grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_FORCE_RST_STREAM);
-    grpc_chttp2_mark_stream_closed(t, s, true, true, GRPC_ERROR_NONE);
-  }
-  GRPC_CHTTP2_STREAM_UNREF(s, "final_rst");
-}
-
-grpc_error_handle grpc_chttp2_header_parser_parse(void* hpack_parser,
-                                                  grpc_chttp2_transport* t,
-                                                  grpc_chttp2_stream* s,
-                                                  const grpc_slice& slice,
-                                                  int is_last) {
-  auto* parser = static_cast<grpc_core::HPackParser*>(hpack_parser);
-  if (s != nullptr) {
-    s->stats.incoming.header_bytes += GRPC_SLICE_LENGTH(slice);
-  }
-  grpc_error_handle error = parser->Parse(slice, is_last != 0);
-  if (!GRPC_ERROR_IS_NONE(error)) {
-    return error;
-  }
-  if (is_last) {
-    /* need to check for null stream: this can occur if we receive an invalid
-       stream id on a header */
-    if (s != nullptr) {
-      if (parser->is_boundary()) {
-        if (s->header_frames_received == 2) {
-          return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "Too many trailer frames");
-        }
-        s->published_metadata[s->header_frames_received] =
-            GRPC_METADATA_PUBLISHED_FROM_WIRE;
-        maybe_complete_funcs[s->header_frames_received](t, s);
-        s->header_frames_received++;
-      }
-      if (parser->is_eof()) {
-        if (t->is_client && !s->write_closed) {
-          /* server eof ==> complete closure; we may need to forcefully close
-             the stream. Wait until the combiner lock is ready to be released
-             however -- it might be that we receive a RST_STREAM following this
-             and can avoid the extra write */
-          GRPC_CHTTP2_STREAM_REF(s, "final_rst");
-          t->combiner->FinallyRun(
-              GRPC_CLOSURE_CREATE(force_client_rst_stream, s, nullptr),
-              GRPC_ERROR_NONE);
-        }
-        grpc_chttp2_mark_stream_closed(t, s, true, false, GRPC_ERROR_NONE);
-      }
-    }
-    parser->FinishFrame();
-  }
-  return GRPC_ERROR_NONE;
-}

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

@@ -1,20 +1,20 @@
-/*
- *
- * 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.
- *
- */
+//
+//
+// 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_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_H
 #define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_H
@@ -131,12 +131,12 @@ class HPackParser {
 
 }  // namespace grpc_core
 
-/* wraps grpc_chttp2_hpack_parser_parse to provide a frame level parser for
-   the transport */
+// wraps grpc_chttp2_hpack_parser_parse to provide a frame level parser for
+// the transport
 grpc_error_handle grpc_chttp2_header_parser_parse(void* hpack_parser,
                                                   grpc_chttp2_transport* t,
                                                   grpc_chttp2_stream* s,
                                                   const grpc_slice& slice,
                                                   int is_last);
 
-#endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_H */
+#endif  // GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_H