grpc 1.41.1 → 1.44.0.pre2

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

@@ -31,7 +31,6 @@
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/slice/slice_utils.h"
 #include "src/core/lib/transport/http2_errors.h"
-#include "src/core/lib/transport/static_metadata.h"
 #include "src/core/lib/transport/status_conversion.h"
 #include "src/core/lib/transport/timeout_encoding.h"
 
@@ -306,11 +305,6 @@ static grpc_error_handle skip_parser(void* /*parser*/,
   return GRPC_ERROR_NONE;
 }
 
-grpc_error_handle skip_header(grpc_mdelem md) {
-  GRPC_MDELEM_UNREF(md);
-  return GRPC_ERROR_NONE;
-}
-
 static HPackParser::Boundary hpack_boundary_type(grpc_chttp2_transport* t,
                                                  bool is_eoh) {
   if (is_eoh) {
@@ -324,13 +318,26 @@ static HPackParser::Boundary hpack_boundary_type(grpc_chttp2_transport* t,
   }
 }
 
+static HPackParser::LogInfo hpack_parser_log_info(
+    grpc_chttp2_transport* t, HPackParser::LogInfo::Type type) {
+  return HPackParser::LogInfo{
+      t->incoming_stream_id,
+      type,
+      t->is_client,
+  };
+}
+
 static grpc_error_handle init_header_skip_frame_parser(
     grpc_chttp2_transport* t, HPackParser::Priority priority_type) {
   bool is_eoh = t->expect_continuation_stream_id != 0;
   t->parser = grpc_chttp2_header_parser_parse;
   t->parser_data = &t->hpack_parser;
-  t->hpack_parser.BeginFrame(skip_header, hpack_boundary_type(t, is_eoh),
-                             priority_type);
+  t->hpack_parser.BeginFrame(
+      nullptr,
+      t->settings[GRPC_ACKED_SETTINGS]
+                 [GRPC_CHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE],
+      hpack_boundary_type(t, is_eoh), priority_type,
+      hpack_parser_log_info(t, HPackParser::LogInfo::kDontKnow));
   return GRPC_ERROR_NONE;
 }
 
@@ -342,7 +349,7 @@ static grpc_error_handle init_non_header_skip_frame_parser(
 
 void grpc_chttp2_parsing_become_skip_parser(grpc_chttp2_transport* t) {
   if (t->parser == grpc_chttp2_header_parser_parse) {
-    t->hpack_parser.ResetSink(skip_header);
+    t->hpack_parser.StopBufferingFrame();
   } else {
     t->parser = skip_parser;
   }
@@ -409,170 +416,6 @@ error_handler:
   }
 }
 
-static void free_timeout(void* p) { gpr_free(p); }
-
-static bool md_key_cmp(grpc_mdelem md, const grpc_slice& reference) {
-  GPR_DEBUG_ASSERT(grpc_slice_is_interned(GRPC_MDKEY(md)));
-  return GRPC_MDKEY(md).refcount == reference.refcount;
-}
-
-static void GPR_ATTRIBUTE_NOINLINE on_initial_header_log(
-    grpc_chttp2_transport* t, grpc_chttp2_stream* s, grpc_mdelem md) {
-  char* key = grpc_slice_to_c_string(GRPC_MDKEY(md));
-  char* value =
-      grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_HEX | GPR_DUMP_ASCII);
-  gpr_log(GPR_INFO, "HTTP:%d:HDR:%s: %s: %s", s->id,
-          t->is_client ? "CLI" : "SVR", key, value);
-  gpr_free(key);
-  gpr_free(value);
-}
-
-static grpc_error_handle GPR_ATTRIBUTE_NOINLINE
-handle_timeout(grpc_chttp2_stream* s, grpc_mdelem md) {
-  grpc_millis* cached_timeout =
-      static_cast<grpc_millis*>(grpc_mdelem_get_user_data(md, free_timeout));
-  grpc_millis timeout;
-  if (cached_timeout != nullptr) {
-    timeout = *cached_timeout;
-  } else {
-    if (GPR_UNLIKELY(!grpc_http2_decode_timeout(GRPC_MDVALUE(md), &timeout))) {
-      char* val = grpc_slice_to_c_string(GRPC_MDVALUE(md));
-      gpr_log(GPR_ERROR, "Ignoring bad timeout value '%s'", val);
-      gpr_free(val);
-      timeout = GRPC_MILLIS_INF_FUTURE;
-    }
-    if (GRPC_MDELEM_IS_INTERNED(md)) {
-      /* store the result */
-      cached_timeout =
-          static_cast<grpc_millis*>(gpr_malloc(sizeof(grpc_millis)));
-      *cached_timeout = timeout;
-      grpc_mdelem_set_user_data(md, free_timeout, cached_timeout);
-    }
-  }
-  if (timeout != GRPC_MILLIS_INF_FUTURE) {
-    grpc_chttp2_incoming_metadata_buffer_set_deadline(
-        &s->metadata_buffer[0], grpc_core::ExecCtx::Get()->Now() + timeout);
-  }
-  GRPC_MDELEM_UNREF(md);
-  return GRPC_ERROR_NONE;
-}
-
-static grpc_error_handle GPR_ATTRIBUTE_NOINLINE
-handle_metadata_size_limit_exceeded(grpc_chttp2_transport* t,
-                                    grpc_chttp2_stream* s, grpc_mdelem md,
-                                    size_t new_size,
-                                    size_t metadata_size_limit) {
-  gpr_log(GPR_DEBUG,
-          "received initial metadata size exceeds limit (%" PRIuPTR
-          " vs. %" PRIuPTR
-          "). GRPC_ARG_MAX_METADATA_SIZE can be set to increase this limit.",
-          new_size, metadata_size_limit);
-  grpc_chttp2_cancel_stream(
-      t, s,
-      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_chttp2_parsing_become_skip_parser(t);
-  s->seen_error = true;
-  GRPC_MDELEM_UNREF(md);
-  return GRPC_ERROR_NONE;
-}
-
-static grpc_error_handle GPR_ATTRIBUTE_NOINLINE
-handle_metadata_add_failure(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
-                            grpc_mdelem md, grpc_error_handle error) {
-  grpc_chttp2_cancel_stream(t, s, error);
-  grpc_chttp2_parsing_become_skip_parser(t);
-  s->seen_error = true;
-  GRPC_MDELEM_UNREF(md);
-  return GRPC_ERROR_NONE;
-}
-
-static grpc_error_handle on_initial_header(void* tp, grpc_mdelem md) {
-  GPR_TIMER_SCOPE("on_initial_header", 0);
-
-  grpc_chttp2_transport* t = static_cast<grpc_chttp2_transport*>(tp);
-  grpc_chttp2_stream* s = t->incoming_stream;
-  GPR_DEBUG_ASSERT(s != nullptr);
-
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
-    on_initial_header_log(t, s, md);
-  }
-
-  if (md_key_cmp(md, GRPC_MDSTR_GRPC_TIMEOUT)) {
-    return handle_timeout(s, md);
-  }
-
-  const size_t new_size = s->metadata_buffer[0].size + GRPC_MDELEM_LENGTH(md);
-  const size_t metadata_size_limit =
-      t->settings[GRPC_ACKED_SETTINGS]
-                 [GRPC_CHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE];
-  if (GPR_UNLIKELY(new_size > metadata_size_limit)) {
-    return handle_metadata_size_limit_exceeded(t, s, md, new_size,
-                                               metadata_size_limit);
-  } else {
-    grpc_error_handle error =
-        grpc_chttp2_incoming_metadata_buffer_add(&s->metadata_buffer[0], md);
-    if (GPR_UNLIKELY(error != GRPC_ERROR_NONE)) {
-      return handle_metadata_add_failure(t, s, md, error);
-    }
-  }
-  // Not timeout-related metadata, and no error occurred.
-  return GRPC_ERROR_NONE;
-}
-
-static grpc_error_handle on_trailing_header(void* tp, grpc_mdelem md) {
-  GPR_TIMER_SCOPE("on_trailing_header", 0);
-
-  grpc_chttp2_transport* t = static_cast<grpc_chttp2_transport*>(tp);
-  grpc_chttp2_stream* s = t->incoming_stream;
-  GPR_DEBUG_ASSERT(s != nullptr);
-
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
-    char* key = grpc_slice_to_c_string(GRPC_MDKEY(md));
-    char* value =
-        grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_HEX | GPR_DUMP_ASCII);
-    gpr_log(GPR_INFO, "HTTP:%d:TRL:%s: %s: %s", s->id,
-            t->is_client ? "CLI" : "SVR", key, value);
-    gpr_free(key);
-    gpr_free(value);
-  }
-
-  const size_t new_size = s->metadata_buffer[1].size + GRPC_MDELEM_LENGTH(md);
-  const size_t metadata_size_limit =
-      t->settings[GRPC_ACKED_SETTINGS]
-                 [GRPC_CHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE];
-  if (new_size > metadata_size_limit) {
-    gpr_log(GPR_DEBUG,
-            "received trailing metadata size exceeds limit (%" PRIuPTR
-            " vs. %" PRIuPTR
-            "). Please note that the status is also included in the trailing "
-            "metadata and a large status message can also trigger this. "
-            "GRPC_ARG_MAX_METADATA_SIZE can be set to increase this limit.",
-            new_size, metadata_size_limit);
-    grpc_chttp2_cancel_stream(
-        t, s,
-        grpc_error_set_int(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                               "received trailing metadata size exceeds limit"),
-                           GRPC_ERROR_INT_GRPC_STATUS,
-                           GRPC_STATUS_RESOURCE_EXHAUSTED));
-    grpc_chttp2_parsing_become_skip_parser(t);
-    s->seen_error = true;
-    GRPC_MDELEM_UNREF(md);
-  } else {
-    grpc_error_handle error =
-        grpc_chttp2_incoming_metadata_buffer_add(&s->metadata_buffer[1], md);
-    if (error != GRPC_ERROR_NONE) {
-      grpc_chttp2_cancel_stream(t, s, error);
-      grpc_chttp2_parsing_become_skip_parser(t);
-      s->seen_error = true;
-      GRPC_MDELEM_UNREF(md);
-    }
-  }
-  return GRPC_ERROR_NONE;
-}
-
 static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
                                                   int is_continuation) {
   const bool is_eoh =
@@ -664,7 +507,8 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
   if (t->header_eof) {
     s->eos_received = true;
   }
-  HPackParser::Sink on_header;
+  grpc_metadata_batch* incoming_metadata_buffer = nullptr;
+  HPackParser::LogInfo::Type frame_type = HPackParser::LogInfo::kDontKnow;
   switch (s->header_frames_received) {
     case 0:
       if (t->is_client && t->header_eof) {
@@ -672,22 +516,29 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
         if (s->trailing_metadata_available != nullptr) {
           *s->trailing_metadata_available = true;
         }
-        on_header = [t](grpc_mdelem md) { return on_trailing_header(t, md); };
+        incoming_metadata_buffer = &s->trailing_metadata_buffer;
+        frame_type = HPackParser::LogInfo::kTrailers;
       } else {
         GRPC_CHTTP2_IF_TRACING(gpr_log(GPR_INFO, "parsing initial_metadata"));
-        on_header = [t](grpc_mdelem md) { return on_initial_header(t, md); };
+        incoming_metadata_buffer = &s->initial_metadata_buffer;
+        frame_type = HPackParser::LogInfo::kHeaders;
       }
       break;
     case 1:
       GRPC_CHTTP2_IF_TRACING(gpr_log(GPR_INFO, "parsing trailing_metadata"));
-      on_header = [t](grpc_mdelem md) { return on_trailing_header(t, md); };
+      incoming_metadata_buffer = &s->trailing_metadata_buffer;
+      frame_type = HPackParser::LogInfo::kTrailers;
       break;
     case 2:
       gpr_log(GPR_ERROR, "too many header frames received");
       return init_header_skip_frame_parser(t, priority_type);
   }
-  t->hpack_parser.BeginFrame(std::move(on_header),
-                             hpack_boundary_type(t, is_eoh), priority_type);
+  t->hpack_parser.BeginFrame(
+      incoming_metadata_buffer,
+      t->settings[GRPC_ACKED_SETTINGS]
+                 [GRPC_CHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE],
+      hpack_boundary_type(t, is_eoh), priority_type,
+      hpack_parser_log_info(t, frame_type));
   return GRPC_ERROR_NONE;
 }
 

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

@@ -25,7 +25,6 @@
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
 #include "src/core/ext/transport/chttp2/transport/context_list.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
-#include "src/core/lib/compression/stream_compression.h"
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -164,24 +163,19 @@ static void report_stall(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
         "%s:%p stream %d moved to stalled list by %s. This is FULLY expected "
         "to happen in a healthy program that is not seeing flow control stalls."
         " However, if you know that there are unwanted stalls, here is some "
-        "helpful data: [fc:pending=%" PRIdPTR ":pending-compressed=%" PRIdPTR
-        ":flowed=%" PRId64 ":peer_initwin=%d:t_win=%" PRId64
-        ":s_win=%d:s_delta=%" PRId64 "]",
+        "helpful data: [fc:pending=%" PRIdPTR ":flowed=%" PRId64
+        ":peer_initwin=%d:t_win=%" PRId64 ":s_win=%d:s_delta=%" PRId64 "]",
         t->peer_string.c_str(), t, s->id, staller,
-        s->flow_controlled_buffer.length,
-        s->stream_compression_method ==
-                GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS
-            ? 0
-            : s->compressed_data_buffer.length,
-        s->flow_controlled_bytes_flowed,
+        s->flow_controlled_buffer.length, s->flow_controlled_bytes_flowed,
         t->settings[GRPC_ACKED_SETTINGS]
                    [GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE],
         t->flow_control->remote_window(),
-        static_cast<uint32_t> GPR_MAX(
-            0,
+        static_cast<uint32_t>(std::max(
+            int64_t(0),
             s->flow_control->remote_window_delta() +
-                (int64_t)t->settings[GRPC_PEER_SETTINGS]
-                                    [GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE]),
+                static_cast<int64_t>(
+                    t->settings[GRPC_PEER_SETTINGS]
+                               [GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE]))),
         s->flow_control->remote_window_delta());
   }
 }
@@ -191,9 +185,30 @@ static uint32_t target_write_size(grpc_chttp2_transport* /*t*/) {
   return 1024 * 1024;
 }
 
+namespace {
+
+class CountDefaultMetadataEncoder {
+ public:
+  size_t count() const { return count_; }
+
+  void Encode(const grpc_core::Slice&, const grpc_core::Slice&) {}
+
+  template <typename Which>
+  void Encode(Which, const typename Which::ValueType&) {
+    count_++;
+  }
+
+ private:
+  size_t count_ = 0;
+};
+
+}  // namespace
+
 // Returns true if initial_metadata contains only default headers.
 static bool is_default_initial_metadata(grpc_metadata_batch* initial_metadata) {
-  return initial_metadata->list.default_count == initial_metadata->list.count;
+  CountDefaultMetadataEncoder enc;
+  initial_metadata->Encode(&enc);
+  return enc.count() == initial_metadata->count();
 }
 
 namespace {
@@ -325,87 +340,36 @@ class DataSendContext {
         sending_bytes_before_(s_->sending_bytes) {}
 
   uint32_t stream_remote_window() const {
-    return static_cast<uint32_t> GPR_MAX(
-        0, s_->flow_control->remote_window_delta() +
-               (int64_t)t_->settings[GRPC_PEER_SETTINGS]
-                                    [GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE]);
+    return static_cast<uint32_t>(std::max(
+        int64_t(0),
+        s_->flow_control->remote_window_delta() +
+            static_cast<int64_t>(
+                t_->settings[GRPC_PEER_SETTINGS]
+                            [GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE])));
   }
 
   uint32_t max_outgoing() const {
-    return static_cast<uint32_t> GPR_MIN(
+    return static_cast<uint32_t>(std::min(
         t_->settings[GRPC_PEER_SETTINGS][GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE],
-        GPR_MIN(stream_remote_window(), t_->flow_control->remote_window()));
+        static_cast<uint32_t>(std::min(int64_t(stream_remote_window()),
+                                       t_->flow_control->remote_window()))));
   }
 
   bool AnyOutgoing() const { return max_outgoing() > 0; }
 
-  void FlushUncompressedBytes() {
-    uint32_t send_bytes = static_cast<uint32_t> GPR_MIN(
-        max_outgoing(), s_->flow_controlled_buffer.length);
+  void FlushBytes() {
+    uint32_t send_bytes = static_cast<uint32_t>(
+        std::min(size_t(max_outgoing()), s_->flow_controlled_buffer.length));
     is_last_frame_ = send_bytes == s_->flow_controlled_buffer.length &&
                      s_->fetching_send_message == nullptr &&
                      s_->send_trailing_metadata != nullptr &&
-                     grpc_metadata_batch_is_empty(s_->send_trailing_metadata);
+                     s_->send_trailing_metadata->empty();
     grpc_chttp2_encode_data(s_->id, &s_->flow_controlled_buffer, send_bytes,
                             is_last_frame_, &s_->stats.outgoing, &t_->outbuf);
     s_->flow_control->SentData(send_bytes);
     s_->sending_bytes += send_bytes;
   }
 
-  void FlushCompressedBytes() {
-    GPR_DEBUG_ASSERT(s_->stream_compression_method !=
-                     GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS);
-
-    uint32_t send_bytes = static_cast<uint32_t> GPR_MIN(
-        max_outgoing(), s_->compressed_data_buffer.length);
-    bool is_last_data_frame =
-        (send_bytes == s_->compressed_data_buffer.length &&
-         s_->flow_controlled_buffer.length == 0 &&
-         s_->fetching_send_message == nullptr);
-    if (is_last_data_frame && s_->send_trailing_metadata != nullptr &&
-        s_->stream_compression_ctx != nullptr) {
-      if (GPR_UNLIKELY(!grpc_stream_compress(
-              s_->stream_compression_ctx, &s_->flow_controlled_buffer,
-              &s_->compressed_data_buffer, nullptr, MAX_SIZE_T,
-              GRPC_STREAM_COMPRESSION_FLUSH_FINISH))) {
-        gpr_log(GPR_ERROR, "Stream compression failed.");
-      }
-      grpc_stream_compression_context_destroy(s_->stream_compression_ctx);
-      s_->stream_compression_ctx = nullptr;
-      /* After finish, bytes in s->compressed_data_buffer may be
-       * more than max_outgoing. Start another round of the current
-       * while loop so that send_bytes and is_last_data_frame are
-       * recalculated. */
-      return;
-    }
-    is_last_frame_ = is_last_data_frame &&
-                     s_->send_trailing_metadata != nullptr &&
-                     grpc_metadata_batch_is_empty(s_->send_trailing_metadata);
-    grpc_chttp2_encode_data(s_->id, &s_->compressed_data_buffer, send_bytes,
-                            is_last_frame_, &s_->stats.outgoing, &t_->outbuf);
-    s_->flow_control->SentData(send_bytes);
-    if (s_->compressed_data_buffer.length == 0) {
-      s_->sending_bytes += s_->uncompressed_data_size;
-    }
-  }
-
-  void CompressMoreBytes() {
-    GPR_DEBUG_ASSERT(s_->stream_compression_method !=
-                     GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS);
-
-    if (s_->stream_compression_ctx == nullptr) {
-      s_->stream_compression_ctx =
-          grpc_stream_compression_context_create(s_->stream_compression_method);
-    }
-    s_->uncompressed_data_size = s_->flow_controlled_buffer.length;
-    if (GPR_UNLIKELY(!grpc_stream_compress(
-            s_->stream_compression_ctx, &s_->flow_controlled_buffer,
-            &s_->compressed_data_buffer, nullptr, MAX_SIZE_T,
-            GRPC_STREAM_COMPRESSION_FLUSH_SYNC))) {
-      gpr_log(GPR_ERROR, "Stream compression failed.");
-    }
-  }
-
   bool is_last_frame() const { return is_last_frame_; }
 
   void CallCallbacks() {
@@ -450,7 +414,6 @@ class StreamWriteContext {
     // https://github.com/grpc/proposal/blob/master/A6-client-retries.md#when-retries-are-valid
     if (!t_->is_client && s_->fetching_send_message == nullptr &&
         s_->flow_controlled_buffer.length == 0 &&
-        compressed_data_buffer_len() == 0 &&
         s_->send_trailing_metadata != nullptr &&
         is_default_initial_metadata(s_->send_initial_metadata)) {
       ConvertInitialMetadataToTrailingMetadata();
@@ -481,13 +444,6 @@ class StreamWriteContext {
         "send_initial_metadata_finished");
   }
 
-  size_t compressed_data_buffer_len() {
-    return s_->stream_compression_method ==
-                   GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS
-               ? 0
-               : s_->compressed_data_buffer.length;
-  }
-
   void FlushWindowUpdates() {
     /* send any window updates */
     const uint32_t stream_announce = s_->flow_control->MaybeSendUpdate();
@@ -503,8 +459,7 @@ class StreamWriteContext {
   void FlushData() {
     if (!s_->sent_initial_metadata) return;
 
-    if (s_->flow_controlled_buffer.length == 0 &&
-        compressed_data_buffer_len() == 0) {
+    if (s_->flow_controlled_buffer.length == 0) {
       return;  // early out: nothing to do
     }
 
@@ -521,22 +476,9 @@ class StreamWriteContext {
       return;  // early out: nothing to do
     }
 
-    if (s_->stream_compression_method ==
-        GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS) {
-      while (s_->flow_controlled_buffer.length > 0 &&
-             data_send_context.max_outgoing() > 0) {
-        data_send_context.FlushUncompressedBytes();
-      }
-    } else {
-      while ((s_->flow_controlled_buffer.length > 0 ||
-              s_->compressed_data_buffer.length > 0) &&
-             data_send_context.max_outgoing() > 0) {
-        if (s_->compressed_data_buffer.length > 0) {
-          data_send_context.FlushCompressedBytes();
-        } else {
-          data_send_context.CompressMoreBytes();
-        }
-      }
+    while (s_->flow_controlled_buffer.length > 0 &&
+           data_send_context.max_outgoing() > 0) {
+      data_send_context.FlushBytes();
     }
     grpc_chttp2_reset_ping_clock(t_);
     if (data_send_context.is_last_frame()) {
@@ -544,8 +486,7 @@ class StreamWriteContext {
     }
     data_send_context.CallCallbacks();
     stream_became_writable_ = true;
-    if (s_->flow_controlled_buffer.length > 0 ||
-        compressed_data_buffer_len() > 0) {
+    if (s_->flow_controlled_buffer.length > 0) {
       GRPC_CHTTP2_STREAM_REF(s_, "chttp2_writing:fork");
       grpc_chttp2_list_add_writable_stream(t_, s_);
     }
@@ -558,13 +499,20 @@ class StreamWriteContext {
     if (s_->send_trailing_metadata == nullptr) return;
     if (s_->fetching_send_message != nullptr) return;
     if (s_->flow_controlled_buffer.length != 0) return;
-    if (compressed_data_buffer_len() != 0) return;
 
     GRPC_CHTTP2_IF_TRACING(gpr_log(GPR_INFO, "sending trailing_metadata"));
-    if (grpc_metadata_batch_is_empty(s_->send_trailing_metadata)) {
+    if (s_->send_trailing_metadata->empty()) {
       grpc_chttp2_encode_data(s_->id, &s_->flow_controlled_buffer, 0, true,
                               &s_->stats.outgoing, &t_->outbuf);
     } else {
+      if (send_status_.has_value()) {
+        s_->send_trailing_metadata->Set(grpc_core::HttpStatusMetadata(),
+                                        *send_status_);
+      }
+      if (send_content_type_.has_value()) {
+        s_->send_trailing_metadata->Set(grpc_core::ContentTypeMetadata(),
+                                        *send_content_type_);
+      }
       t_->hpack_compressor.EncodeHeaders(
           grpc_core::HPackCompressor::EncodeHeaderOptions{
               s_->id, true,
@@ -575,12 +523,7 @@ class StreamWriteContext {
               t_->settings[GRPC_PEER_SETTINGS]
                           [GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE],
               &s_->stats.outgoing},
-          grpc_core::ConcatMetadata(
-              grpc_core::MetadataArray(
-                  extra_headers_for_trailing_metadata_,
-                  num_extra_headers_for_trailing_metadata_),
-              *s_->send_trailing_metadata),
-          &t_->outbuf);
+          *s_->send_trailing_metadata, &t_->outbuf);
     }
     write_context_->IncTrailingMetadataWrites();
     grpc_chttp2_reset_ping_clock(t_);
@@ -600,16 +543,10 @@ class StreamWriteContext {
         gpr_log(GPR_INFO, "not sending initial_metadata (Trailers-Only)"));
     // When sending Trailers-Only, we need to move the :status and
     // content-type headers to the trailers.
-    if (s_->send_initial_metadata->idx.named.status != nullptr) {
-      extra_headers_for_trailing_metadata_
-          [num_extra_headers_for_trailing_metadata_++] =
-              &s_->send_initial_metadata->idx.named.status->md;
-    }
-    if (s_->send_initial_metadata->idx.named.content_type != nullptr) {
-      extra_headers_for_trailing_metadata_
-          [num_extra_headers_for_trailing_metadata_++] =
-              &s_->send_initial_metadata->idx.named.content_type->md;
-    }
+    send_status_ =
+        s_->send_initial_metadata->get(grpc_core::HttpStatusMetadata());
+    send_content_type_ =
+        s_->send_initial_metadata->get(grpc_core::ContentTypeMetadata());
   }
 
   void SentLastFrame() {
@@ -634,8 +571,9 @@ class StreamWriteContext {
   grpc_chttp2_transport* const t_;
   grpc_chttp2_stream* const s_;
   bool stream_became_writable_ = false;
-  grpc_mdelem* extra_headers_for_trailing_metadata_[2];
-  size_t num_extra_headers_for_trailing_metadata_ = 0;
+  absl::optional<uint32_t> send_status_;
+  absl::optional<grpc_core::ContentTypeMetadata::ValueType> send_content_type_ =
+      {};
 };
 }  // namespace
 

data/src/core/ext/transport/inproc/inproc_plugin.cc

@@ -22,7 +22,3 @@
 #include "src/core/lib/debug/trace.h"
 
 grpc_core::TraceFlag grpc_inproc_trace(false, "inproc");
-
-void grpc_inproc_plugin_init(void) { grpc_inproc_transport_init(); }
-
-void grpc_inproc_plugin_shutdown(void) { grpc_inproc_transport_shutdown(); }