grpc 1.52.0 → 1.53.0

data/src/core/ext/filters/deadline/deadline_filter.h

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_DEADLINE_DEADLINE_FILTER_H
-#define GRPC_CORE_EXT_FILTERS_DEADLINE_DEADLINE_FILTER_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_DEADLINE_DEADLINE_FILTER_H
+#define GRPC_SRC_CORE_EXT_FILTERS_DEADLINE_DEADLINE_FILTER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -41,6 +41,7 @@ struct grpc_deadline_state {
   ~grpc_deadline_state();
 
   // We take a reference to the call stack for the timer callback.
+  grpc_call_element* elem;
   grpc_call_stack* call_stack;
   grpc_core::CallCombiner* call_combiner;
   grpc_core::Arena* arena;
@@ -53,11 +54,6 @@ struct grpc_deadline_state {
   grpc_closure* original_recv_trailing_metadata_ready;
 };
 
-//
-// NOTE: All of these functions require that the first field in
-// elem->call_data is a grpc_deadline_state.
-//
-
 // Cancels the existing timer and starts a new one with new_deadline.
 //
 // Note: It is generally safe to call this with an earlier deadline
@@ -67,7 +63,7 @@ struct grpc_deadline_state {
 // deadline may result in the timer being called twice.
 //
 // Note: Must be called while holding the call combiner.
-void grpc_deadline_state_reset(grpc_call_element* elem,
+void grpc_deadline_state_reset(grpc_deadline_state* deadline_state,
                                grpc_core::Timestamp new_deadline);
 
 // To be called from the client-side filter's start_transport_stream_op_batch()
@@ -79,7 +75,7 @@ void grpc_deadline_state_reset(grpc_call_element* elem,
 //
 // Note: Must be called while holding the call combiner.
 void grpc_deadline_state_client_start_transport_stream_op_batch(
-    grpc_call_element* elem, grpc_transport_stream_op_batch* op);
+    grpc_deadline_state* deadline_state, grpc_transport_stream_op_batch* op);
 
 // Should deadline checking be performed (according to channel args)
 bool grpc_deadline_checking_enabled(const grpc_core::ChannelArgs& args);
@@ -90,4 +86,4 @@ bool grpc_deadline_checking_enabled(const grpc_core::ChannelArgs& args);
 extern const grpc_channel_filter grpc_client_deadline_filter;
 extern const grpc_channel_filter grpc_server_deadline_filter;
 
-#endif  // GRPC_CORE_EXT_FILTERS_DEADLINE_DEADLINE_FILTER_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_DEADLINE_DEADLINE_FILTER_H

data/src/core/ext/filters/fault_injection/fault_injection_filter.h

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_FAULT_INJECTION_FAULT_INJECTION_FILTER_H
-#define GRPC_CORE_EXT_FILTERS_FAULT_INJECTION_FAULT_INJECTION_FILTER_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_FAULT_INJECTION_FAULT_INJECTION_FILTER_H
+#define GRPC_SRC_CORE_EXT_FILTERS_FAULT_INJECTION_FAULT_INJECTION_FILTER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -68,4 +68,4 @@ class FaultInjectionFilter : public ChannelFilter {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_FAULT_INJECTION_FAULT_INJECTION_FILTER_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_FAULT_INJECTION_FAULT_INJECTION_FILTER_H

data/src/core/ext/filters/fault_injection/fault_injection_service_config_parser.h

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_FAULT_INJECTION_FAULT_INJECTION_SERVICE_CONFIG_PARSER_H
-#define GRPC_CORE_EXT_FILTERS_FAULT_INJECTION_FAULT_INJECTION_SERVICE_CONFIG_PARSER_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_FAULT_INJECTION_FAULT_INJECTION_SERVICE_CONFIG_PARSER_H
+#define GRPC_SRC_CORE_EXT_FILTERS_FAULT_INJECTION_FAULT_INJECTION_SERVICE_CONFIG_PARSER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -109,4 +109,4 @@ class FaultInjectionServiceConfigParser final
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_FAULT_INJECTION_FAULT_INJECTION_SERVICE_CONFIG_PARSER_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_FAULT_INJECTION_FAULT_INJECTION_SERVICE_CONFIG_PARSER_H

data/src/core/ext/filters/http/client/http_client_filter.cc

@@ -21,6 +21,7 @@
 
 #include <algorithm>
 #include <functional>
+#include <initializer_list>
 #include <memory>
 #include <string>
 #include <utility>
@@ -39,10 +40,11 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/promise/context.h"
-#include "src/core/lib/promise/detail/basic_seq.h"
 #include "src/core/lib/promise/latch.h"
-#include "src/core/lib/promise/seq.h"
-#include "src/core/lib/promise/try_concurrently.h"
+#include "src/core/lib/promise/map.h"
+#include "src/core/lib/promise/pipe.h"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/promise/race.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/percent_encoding.h"
 #include "src/core/lib/transport/status_conversion.h"
@@ -117,24 +119,27 @@ ArenaPromise<ServerMetadataHandle> HttpClientFilter::MakeCallPromise(
   md->Set(ContentTypeMetadata(), ContentTypeMetadata::kApplicationGrpc);
   md->Set(UserAgentMetadata(), user_agent_.Ref());
 
-  auto* read_latch = GetContext<Arena>()->New<Latch<ServerMetadata*>>();
-  auto* write_latch =
-      std::exchange(call_args.server_initial_metadata, read_latch);
-
-  return TryConcurrently(
-             Seq(next_promise_factory(std::move(call_args)),
-                 [](ServerMetadataHandle md) -> ServerMetadataHandle {
-                   auto r = CheckServerMetadata(md.get());
-                   if (!r.ok()) return ServerMetadataFromStatus(r);
-                   return md;
-                 }))
-      .NecessaryPull(Seq(read_latch->Wait(),
-                         [write_latch](ServerMetadata** md) -> absl::Status {
-                           auto r = *md == nullptr ? absl::OkStatus()
-                                                   : CheckServerMetadata(*md);
-                           write_latch->Set(*md);
-                           return r;
-                         }));
+  auto* initial_metadata_err =
+      GetContext<Arena>()->New<Latch<ServerMetadataHandle>>();
+
+  call_args.server_initial_metadata->InterceptAndMap(
+      [initial_metadata_err](
+          ServerMetadataHandle md) -> absl::optional<ServerMetadataHandle> {
+        auto r = CheckServerMetadata(md.get());
+        if (!r.ok()) {
+          initial_metadata_err->Set(ServerMetadataFromStatus(r));
+          return absl::nullopt;
+        }
+        return std::move(md);
+      });
+
+  return Race(Map(next_promise_factory(std::move(call_args)),
+                  [](ServerMetadataHandle md) -> ServerMetadataHandle {
+                    auto r = CheckServerMetadata(md.get());
+                    if (!r.ok()) return ServerMetadataFromStatus(r);
+                    return md;
+                  }),
+              initial_metadata_err->Wait());
 }
 
 HttpClientFilter::HttpClientFilter(HttpSchemeMetadata::ValueType scheme,

data/src/core/ext/filters/http/client/http_client_filter.h

@@ -15,8 +15,8 @@
 //
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_HTTP_CLIENT_HTTP_CLIENT_FILTER_H
-#define GRPC_CORE_EXT_FILTERS_HTTP_CLIENT_HTTP_CLIENT_FILTER_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_HTTP_CLIENT_HTTP_CLIENT_FILTER_H
+#define GRPC_SRC_CORE_EXT_FILTERS_HTTP_CLIENT_HTTP_CLIENT_FILTER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -58,4 +58,4 @@ class HttpClientFilter : public ChannelFilter {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_HTTP_CLIENT_HTTP_CLIENT_FILTER_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_HTTP_CLIENT_HTTP_CLIENT_FILTER_H

data/src/core/ext/filters/http/client_authority_filter.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_HTTP_CLIENT_AUTHORITY_FILTER_H
-#define GRPC_CORE_EXT_FILTERS_HTTP_CLIENT_AUTHORITY_FILTER_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_HTTP_CLIENT_AUTHORITY_FILTER_H
+#define GRPC_SRC_CORE_EXT_FILTERS_HTTP_CLIENT_AUTHORITY_FILTER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -53,4 +53,4 @@ class ClientAuthorityFilter final : public ChannelFilter {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_HTTP_CLIENT_AUTHORITY_FILTER_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_HTTP_CLIENT_AUTHORITY_FILTER_H

data/src/core/ext/filters/http/message_compress/compression_filter.cc

@@ -19,8 +19,9 @@
 #include <inttypes.h>
 
 #include <functional>
+#include <initializer_list>
 #include <memory>
-#include <type_traits>
+#include <string>
 #include <utility>
 
 #include "absl/meta/type_traits.h"
@@ -42,17 +43,16 @@
 #include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/compression/message_compress.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/context.h"
-#include "src/core/lib/promise/detail/promise_like.h"
 #include "src/core/lib/promise/latch.h"
-#include "src/core/lib/promise/map_pipe.h"
 #include "src/core/lib/promise/pipe.h"
-#include "src/core/lib/promise/promise.h"
-#include "src/core/lib/promise/seq.h"
-#include "src/core/lib/promise/try_concurrently.h"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/promise/race.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/surface/call.h"
+#include "src/core/lib/surface/call_trace.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 
@@ -157,20 +157,19 @@ MessageHandle CompressionFilter::CompressMessage(
 }
 
 absl::StatusOr<MessageHandle> CompressionFilter::DecompressMessage(
-    MessageHandle message, grpc_compression_algorithm algorithm,
-    absl::optional<uint32_t> max_recv_message_length) const {
+    MessageHandle message, DecompressArgs args) const {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_compression_trace)) {
     gpr_log(GPR_ERROR, "DecompressMessage: len=%" PRIdPTR " max=%d alg=%d",
-            message->payload()->Length(), max_recv_message_length.value_or(-1),
-            algorithm);
+            message->payload()->Length(),
+            args.max_recv_message_length.value_or(-1), args.algorithm);
   }
   // Check max message length.
-  if (max_recv_message_length.has_value() &&
+  if (args.max_recv_message_length.has_value() &&
       message->payload()->Length() >
-          static_cast<size_t>(*max_recv_message_length)) {
+          static_cast<size_t>(*args.max_recv_message_length)) {
     return absl::ResourceExhaustedError(absl::StrFormat(
         "Received message larger than max (%u vs. %d)",
-        message->payload()->Length(), *max_recv_message_length));
+        message->payload()->Length(), *args.max_recv_message_length));
   }
   // Check if decompression is enabled (if not, we can just pass the message
   // up).
@@ -180,11 +179,11 @@ absl::StatusOr<MessageHandle> CompressionFilter::DecompressMessage(
   }
   // Try to decompress the payload.
   SliceBuffer decompressed_slices;
-  if (grpc_msg_decompress(algorithm, message->payload()->c_slice_buffer(),
+  if (grpc_msg_decompress(args.algorithm, message->payload()->c_slice_buffer(),
                           decompressed_slices.c_slice_buffer()) == 0) {
     return absl::InternalError(
         absl::StrCat("Unexpected error decompressing data for algorithm ",
-                     CompressionAlgorithmAsString(algorithm)));
+                     CompressionAlgorithmAsString(args.algorithm)));
   }
   // Swap the decompressed slices into the message.
   message->payload()->Swap(&decompressed_slices);
@@ -193,123 +192,116 @@ absl::StatusOr<MessageHandle> CompressionFilter::DecompressMessage(
   return std::move(message);
 }
 
-class CompressionFilter::DecompressLoop {
- public:
-  explicit DecompressLoop(CompressionFilter* filter, CallArgs& call_args)
-      : filter_(filter),
-        mapper_(PipeMapper<MessageHandle>::Intercept(
-            *call_args.incoming_messages)) {}
-
-  // Once we have a compression algorithm we can construct the decompression
-  // loop.
-  // Returns a promise that resolves to MessageHandle.
-  auto TakeAndRun(grpc_compression_algorithm algorithm) {
-    // Configure max receive size.
-    auto max_recv_message_length = filter_->max_recv_size_;
-    const MessageSizeParsedConfig* limits =
-        MessageSizeParsedConfig::GetFromCallContext(
-            GetContext<grpc_call_context_element>(),
-            filter_->message_size_service_config_parser_index_);
-    if (limits != nullptr && limits->max_recv_size().has_value() &&
-        (!max_recv_message_length.has_value() ||
-         *limits->max_recv_size() < *max_recv_message_length)) {
-      max_recv_message_length = *limits->max_recv_size();
-    }
-    // Interject decompression into the message loop.
-    return mapper_.TakeAndRun([algorithm, max_recv_message_length,
-                               filter = filter_](MessageHandle message) {
-      return filter->DecompressMessage(std::move(message), algorithm,
-                                       max_recv_message_length);
-    });
+grpc_compression_algorithm CompressionFilter::HandleOutgoingMetadata(
+    grpc_metadata_batch& outgoing_metadata) {
+  const auto algorithm = outgoing_metadata.Take(GrpcInternalEncodingRequest())
+                             .value_or(default_compression_algorithm());
+  // Convey supported compression algorithms.
+  outgoing_metadata.Set(GrpcAcceptEncodingMetadata(),
+                        enabled_compression_algorithms());
+  if (algorithm != GRPC_COMPRESS_NONE) {
+    outgoing_metadata.Set(GrpcEncodingMetadata(), algorithm);
   }
+  return algorithm;
+}
 
- private:
-  CompressionFilter* filter_;
-  PipeMapper<MessageHandle> mapper_;
-};
-
-class CompressionFilter::CompressLoop {
- public:
-  explicit CompressLoop(CompressionFilter* filter, CallArgs& call_args)
-      : filter_(filter),
-        mapper_(PipeMapper<MessageHandle>::Intercept(
-            *call_args.outgoing_messages)) {}
-
-  // Once we're ready to send initial metadata we can construct the compression
-  // loop.
-  // Returns a promise that resolves to MessageHandle.
-  auto TakeAndRun(grpc_metadata_batch& outgoing_metadata) {
-    const auto algorithm =
-        outgoing_metadata.Take(GrpcInternalEncodingRequest())
-            .value_or(filter_->default_compression_algorithm());
-    // Convey supported compression algorithms.
-    outgoing_metadata.Set(GrpcAcceptEncodingMetadata(),
-                          filter_->enabled_compression_algorithms());
-    if (algorithm != GRPC_COMPRESS_NONE) {
-      outgoing_metadata.Set(GrpcEncodingMetadata(), algorithm);
-    }
-    // Interject compression into the message loop.
-    return mapper_.TakeAndRun([filter = filter_, algorithm](MessageHandle m) {
-      return filter->CompressMessage(std::move(m), algorithm);
-    });
+CompressionFilter::DecompressArgs CompressionFilter::HandleIncomingMetadata(
+    const grpc_metadata_batch& incoming_metadata) {
+  // Configure max receive size.
+  auto max_recv_message_length = max_recv_size_;
+  const MessageSizeParsedConfig* limits =
+      MessageSizeParsedConfig::GetFromCallContext(
+          GetContext<grpc_call_context_element>(),
+          message_size_service_config_parser_index_);
+  if (limits != nullptr && limits->max_recv_size().has_value() &&
+      (!max_recv_message_length.has_value() ||
+       *limits->max_recv_size() < *max_recv_message_length)) {
+    max_recv_message_length = *limits->max_recv_size();
   }
-
- private:
-  CompressionFilter* filter_;
-  PipeMapper<MessageHandle> mapper_;
-};
+  return DecompressArgs{incoming_metadata.get(GrpcEncodingMetadata())
+                            .value_or(GRPC_COMPRESS_NONE),
+                        max_recv_message_length};
+}
 
 ArenaPromise<ServerMetadataHandle> ClientCompressionFilter::MakeCallPromise(
     CallArgs call_args, NextPromiseFactory next_promise_factory) {
-  auto compress_loop = CompressLoop(this, call_args)
-                           .TakeAndRun(*call_args.client_initial_metadata);
-  DecompressLoop decompress_loop(this, call_args);
-  auto* server_initial_metadata = call_args.server_initial_metadata;
-  // Concurrently:
-  // - call the next filter
-  // - wait for initial metadata from the server and then commence decompression
-  // - compress outgoing messages
-  return TryConcurrently(next_promise_factory(std::move(call_args)))
-      .NecessaryPull(Seq(server_initial_metadata->Wait(),
-                         [decompress_loop = std::move(decompress_loop)](
-                             ServerMetadata** server_initial_metadata) mutable
-                         -> ArenaPromise<absl::Status> {
-                           if (*server_initial_metadata == nullptr) {
-                             return ImmediateOkStatus();
-                           }
-                           return decompress_loop.TakeAndRun(
-                               (*server_initial_metadata)
-                                   ->get(GrpcEncodingMetadata())
-                                   .value_or(GRPC_COMPRESS_NONE));
-                         }))
-      .Push(std::move(compress_loop));
+  auto compression_algorithm =
+      HandleOutgoingMetadata(*call_args.client_initial_metadata);
+  call_args.client_to_server_messages->InterceptAndMap(
+      [compression_algorithm,
+       this](MessageHandle message) -> absl::optional<MessageHandle> {
+        return CompressMessage(std::move(message), compression_algorithm);
+      });
+  auto* decompress_args = GetContext<Arena>()->New<DecompressArgs>(
+      DecompressArgs{GRPC_COMPRESS_NONE, absl::nullopt});
+  auto* decompress_err =
+      GetContext<Arena>()->New<Latch<ServerMetadataHandle>>();
+  call_args.server_initial_metadata->InterceptAndMap(
+      [decompress_args, this](ServerMetadataHandle server_initial_metadata)
+          -> absl::optional<ServerMetadataHandle> {
+        if (server_initial_metadata == nullptr) return absl::nullopt;
+        *decompress_args = HandleIncomingMetadata(*server_initial_metadata);
+        return std::move(server_initial_metadata);
+      });
+  call_args.server_to_client_messages->InterceptAndMap(
+      [decompress_err, decompress_args,
+       this](MessageHandle message) -> absl::optional<MessageHandle> {
+        auto r = DecompressMessage(std::move(message), *decompress_args);
+        if (!r.ok()) {
+          decompress_err->Set(ServerMetadataFromStatus(r.status()));
+          return absl::nullopt;
+        }
+        return std::move(*r);
+      });
+  // Run the next filter, and race it with getting an error from decompression.
+  return Race(next_promise_factory(std::move(call_args)),
+              decompress_err->Wait());
 }
 
 ArenaPromise<ServerMetadataHandle> ServerCompressionFilter::MakeCallPromise(
     CallArgs call_args, NextPromiseFactory next_promise_factory) {
-  CompressLoop compress_loop(this, call_args);
-  auto decompress_loop = DecompressLoop(this, call_args)
-                             .TakeAndRun(call_args.client_initial_metadata
-                                             ->get(GrpcEncodingMetadata())
-                                             .value_or(GRPC_COMPRESS_NONE));
-  auto* read_latch = GetContext<Arena>()->New<Latch<ServerMetadata*>>();
-  auto* write_latch =
-      std::exchange(call_args.server_initial_metadata, read_latch);
+  auto decompress_args =
+      HandleIncomingMetadata(*call_args.client_initial_metadata);
+  auto* decompress_err =
+      GetContext<Arena>()->New<Latch<ServerMetadataHandle>>();
+  call_args.client_to_server_messages->InterceptAndMap(
+      [decompress_err, decompress_args,
+       this](MessageHandle message) -> absl::optional<MessageHandle> {
+        auto r = DecompressMessage(std::move(message), decompress_args);
+        if (grpc_call_trace.enabled()) {
+          gpr_log(GPR_DEBUG, "DecompressMessage returned %s",
+                  r.status().ToString().c_str());
+        }
+        if (!r.ok()) {
+          decompress_err->Set(ServerMetadataFromStatus(r.status()));
+          return absl::nullopt;
+        }
+        return std::move(*r);
+      });
+  auto* compression_algorithm =
+      GetContext<Arena>()->New<grpc_compression_algorithm>();
+  call_args.server_initial_metadata->InterceptAndMap(
+      [this, compression_algorithm](ServerMetadataHandle md) {
+        if (grpc_call_trace.enabled()) {
+          gpr_log(GPR_INFO, "%s[compression] Write metadata",
+                  Activity::current()->DebugTag().c_str());
+        }
+        // Find the compression algorithm.
+        *compression_algorithm = HandleOutgoingMetadata(*md);
+        return md;
+      });
+  call_args.server_to_client_messages->InterceptAndMap(
+      [compression_algorithm,
+       this](MessageHandle message) -> absl::optional<MessageHandle> {
+        return CompressMessage(std::move(message), *compression_algorithm);
+      });
   // Concurrently:
   // - call the next filter
   // - decompress incoming messages
   // - wait for initial metadata to be sent, and then commence compression of
   //   outgoing messages
-  return TryConcurrently(next_promise_factory(std::move(call_args)))
-      .Pull(std::move(decompress_loop))
-      .Push(Seq(read_latch->Wait(),
-                [write_latch, compress_loop = std::move(compress_loop)](
-                    ServerMetadata** md) mutable {
-                  // Find the compression algorithm.
-                  auto loop = compress_loop.TakeAndRun(**md);
-                  write_latch->Set(*md);
-                  return loop;
-                }));
+  return Race(next_promise_factory(std::move(call_args)),
+              decompress_err->Wait());
 }
 
 }  // namespace grpc_core

data/src/core/ext/filters/http/message_compress/compression_filter.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_HTTP_MESSAGE_COMPRESS_COMPRESSION_FILTER_H
-#define GRPC_CORE_EXT_FILTERS_HTTP_MESSAGE_COMPRESS_COMPRESSION_FILTER_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_HTTP_MESSAGE_COMPRESS_COMPRESSION_FILTER_H
+#define GRPC_SRC_CORE_EXT_FILTERS_HTTP_MESSAGE_COMPRESS_COMPRESSION_FILTER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -34,6 +34,7 @@
 #include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/promise/arena_promise.h"
+#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
@@ -62,10 +63,12 @@ namespace grpc_core {
 
 class CompressionFilter : public ChannelFilter {
  protected:
-  explicit CompressionFilter(const ChannelArgs& args);
+  struct DecompressArgs {
+    grpc_compression_algorithm algorithm;
+    absl::optional<uint32_t> max_recv_message_length;
+  };
 
-  class CompressLoop;
-  class DecompressLoop;
+  explicit CompressionFilter(const ChannelArgs& args);
 
   grpc_compression_algorithm default_compression_algorithm() const {
     return default_compression_algorithm_;
@@ -75,15 +78,19 @@ class CompressionFilter : public ChannelFilter {
     return enabled_compression_algorithms_;
   }
 
- private:
+  grpc_compression_algorithm HandleOutgoingMetadata(
+      grpc_metadata_batch& outgoing_metadata);
+  DecompressArgs HandleIncomingMetadata(
+      const grpc_metadata_batch& incoming_metadata);
+
   // Compress one message synchronously.
   MessageHandle CompressMessage(MessageHandle message,
                                 grpc_compression_algorithm algorithm) const;
   // Decompress one message synchronously.
-  absl::StatusOr<MessageHandle> DecompressMessage(
-      MessageHandle message, grpc_compression_algorithm algorithm,
-      absl::optional<uint32_t> max_recv_message_length) const;
+  absl::StatusOr<MessageHandle> DecompressMessage(MessageHandle message,
+                                                  DecompressArgs args) const;
 
+ private:
   // Max receive message length, if set.
   absl::optional<uint32_t> max_recv_size_;
   size_t message_size_service_config_parser_index_;
@@ -129,4 +136,4 @@ class ServerCompressionFilter final : public CompressionFilter {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_HTTP_MESSAGE_COMPRESS_COMPRESSION_FILTER_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_HTTP_MESSAGE_COMPRESS_COMPRESSION_FILTER_H

data/src/core/ext/filters/http/server/http_server_filter.cc

@@ -22,6 +22,7 @@
 
 #include <functional>
 #include <memory>
+#include <string>
 #include <utility>
 
 #include "absl/base/attributes.h"
@@ -30,18 +31,19 @@
 #include "absl/types/optional.h"
 
 #include <grpc/grpc.h>
+#include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/promise/context.h"
-#include "src/core/lib/promise/detail/basic_seq.h"
-#include "src/core/lib/promise/latch.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/map.h"
+#include "src/core/lib/promise/pipe.h"
+#include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/promise.h"
-#include "src/core/lib/promise/seq.h"
-#include "src/core/lib/promise/try_concurrently.h"
-#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/percent_encoding.h"
 #include "src/core/lib/slice/slice.h"
+#include "src/core/lib/surface/call_trace.h"
 #include "src/core/lib/transport/metadata_batch.h"
 
 namespace grpc_core {
@@ -129,24 +131,23 @@ ArenaPromise<ServerMetadataHandle> HttpServerFilter::MakeCallPromise(
     md->Remove(UserAgentMetadata());
   }
 
-  auto* read_latch = GetContext<Arena>()->New<Latch<ServerMetadata*>>();
-  auto* write_latch =
-      std::exchange(call_args.server_initial_metadata, read_latch);
-
-  return TryConcurrently(
-             Seq(next_promise_factory(std::move(call_args)),
-                 [](ServerMetadataHandle md) -> ServerMetadataHandle {
-                   FilterOutgoingMetadata(md.get());
-                   return md;
-                 }))
-      .Push(Seq(read_latch->Wait(), [write_latch](ServerMetadata** md) {
-        FilterOutgoingMetadata(*md);
-        (*md)->Set(HttpStatusMetadata(), 200);
-        (*md)->Set(ContentTypeMetadata(),
-                   ContentTypeMetadata::kApplicationGrpc);
-        write_latch->Set(*md);
-        return absl::OkStatus();
-      }));
+  call_args.server_initial_metadata->InterceptAndMap(
+      [](ServerMetadataHandle md) {
+        if (grpc_call_trace.enabled()) {
+          gpr_log(GPR_INFO, "%s[http-server] Write metadata",
+                  Activity::current()->DebugTag().c_str());
+        }
+        FilterOutgoingMetadata(md.get());
+        md->Set(HttpStatusMetadata(), 200);
+        md->Set(ContentTypeMetadata(), ContentTypeMetadata::kApplicationGrpc);
+        return md;
+      });
+
+  return Map(next_promise_factory(std::move(call_args)),
+             [](ServerMetadataHandle md) -> ServerMetadataHandle {
+               FilterOutgoingMetadata(md.get());
+               return md;
+             });
 }
 
 absl::StatusOr<HttpServerFilter> HttpServerFilter::Create(

data/src/core/ext/filters/http/server/http_server_filter.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_HTTP_SERVER_HTTP_SERVER_FILTER_H
-#define GRPC_CORE_EXT_FILTERS_HTTP_SERVER_HTTP_SERVER_FILTER_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_HTTP_SERVER_HTTP_SERVER_FILTER_H
+#define GRPC_SRC_CORE_EXT_FILTERS_HTTP_SERVER_HTTP_SERVER_FILTER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -60,4 +60,4 @@ class HttpServerFilter : public ChannelFilter {
   "grpc.http.do_not_use_unless_you_have_permission_from_grpc_team_allow_"                       \
   "broken_put_requests"
 
-#endif  // GRPC_CORE_EXT_FILTERS_HTTP_SERVER_HTTP_SERVER_FILTER_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_HTTP_SERVER_HTTP_SERVER_FILTER_H