grpc 1.46.3-x86_64-linux → 1.48.0-x86_64-linux

data/src/core/ext/filters/client_channel/subchannel_stream_client.cc

@@ -18,14 +18,22 @@
 
 #include "src/core/ext/filters/client_channel/subchannel_stream_client.h"
 
-#include <stdint.h>
+#include <inttypes.h>
 #include <stdio.h>
 
+#include <string>
+#include <utility>
+
 #include <grpc/status.h>
+#include <grpc/support/log.h>
 
+#include "src/core/lib/gpr/time_precise.h"
+#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/resource_quota/api.h"
-#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/transport/error_utils.h"
 
 #define SUBCHANNEL_STREAM_INITIAL_CONNECT_BACKOFF_SECONDS 1
@@ -50,7 +58,8 @@ SubchannelStreamClient::SubchannelStreamClient(
       call_allocator_(
           ResourceQuotaFromChannelArgs(connected_subchannel_->args())
               ->memory_quota()
-              ->CreateMemoryAllocator(tracer)),
+              ->CreateMemoryAllocator(
+                  (tracer != nullptr) ? tracer : "SubchannelStreamClient")),
       event_handler_(std::move(event_handler)),
       retry_backoff_(
           BackOff::Options()
@@ -137,7 +146,7 @@ void SubchannelStreamClient::OnRetryTimer(void* arg, grpc_error_handle error) {
   {
     MutexLock lock(&self->mu_);
     self->retry_timer_callback_pending_ = false;
-    if (self->event_handler_ != nullptr && error == GRPC_ERROR_NONE &&
+    if (self->event_handler_ != nullptr && GRPC_ERROR_IS_NONE(error) &&
         self->call_state_ == nullptr) {
       if (GPR_UNLIKELY(self->tracer_ != nullptr)) {
         gpr_log(GPR_INFO,
@@ -209,7 +218,7 @@ void SubchannelStreamClient::CallState::StartCallLocked() {
                     this, grpc_schedule_on_exec_ctx);
   call_->SetAfterCallStackDestroy(&after_call_stack_destruction_);
   // Check if creation failed.
-  if (error != GRPC_ERROR_NONE ||
+  if (!GRPC_ERROR_IS_NONE(error) ||
       subchannel_stream_client_->event_handler_ == nullptr) {
     gpr_log(GPR_ERROR,
             "SubchannelStreamClient %p CallState %p: error creating "
@@ -231,21 +240,16 @@ void SubchannelStreamClient::CallState::StartCallLocked() {
   send_initial_metadata_.Set(
       HttpPathMetadata(),
       subchannel_stream_client_->event_handler_->GetPathLocked());
-  GPR_ASSERT(error == GRPC_ERROR_NONE);
+  GPR_ASSERT(GRPC_ERROR_IS_NONE(error));
   payload_.send_initial_metadata.send_initial_metadata =
       &send_initial_metadata_;
   payload_.send_initial_metadata.send_initial_metadata_flags = 0;
   payload_.send_initial_metadata.peer_string = nullptr;
   batch_.send_initial_metadata = true;
   // Add send_message op.
-  grpc_slice request_slice =
-      subchannel_stream_client_->event_handler_->EncodeSendMessageLocked();
-  grpc_slice_buffer slice_buffer;
-  grpc_slice_buffer_init(&slice_buffer);
-  grpc_slice_buffer_add(&slice_buffer, request_slice);
-  send_message_.emplace(&slice_buffer, 0);
-  grpc_slice_buffer_destroy_internal(&slice_buffer);
-  payload_.send_message.send_message.reset(&*send_message_);
+  send_message_.Append(Slice(
+      subchannel_stream_client_->event_handler_->EncodeSendMessageLocked()));
+  payload_.send_message.send_message = &send_message_;
   batch_.send_message = true;
   // Add send_trailing_metadata op.
   payload_.send_trailing_metadata.send_trailing_metadata =
@@ -360,42 +364,18 @@ void SubchannelStreamClient::CallState::RecvInitialMetadataReady(
   self->call_->Unref(DEBUG_LOCATION, "recv_initial_metadata_ready");
 }
 
-void SubchannelStreamClient::CallState::DoneReadingRecvMessage(
-    grpc_error_handle error) {
-  recv_message_.reset();
-  if (error != GRPC_ERROR_NONE) {
-    GRPC_ERROR_UNREF(error);
-    Cancel();
-    grpc_slice_buffer_destroy_internal(&recv_message_buffer_);
+void SubchannelStreamClient::CallState::RecvMessageReady() {
+  if (!recv_message_.has_value()) {
     call_->Unref(DEBUG_LOCATION, "recv_message_ready");
     return;
   }
-  // Concatenate the slices to form a single string.
-  std::unique_ptr<uint8_t> recv_message_deleter;
-  uint8_t* recv_message;
-  if (recv_message_buffer_.count == 1) {
-    recv_message = GRPC_SLICE_START_PTR(recv_message_buffer_.slices[0]);
-  } else {
-    recv_message =
-        static_cast<uint8_t*>(gpr_malloc(recv_message_buffer_.length));
-    recv_message_deleter.reset(recv_message);
-    size_t offset = 0;
-    for (size_t i = 0; i < recv_message_buffer_.count; ++i) {
-      memcpy(recv_message + offset,
-             GRPC_SLICE_START_PTR(recv_message_buffer_.slices[i]),
-             GRPC_SLICE_LENGTH(recv_message_buffer_.slices[i]));
-      offset += GRPC_SLICE_LENGTH(recv_message_buffer_.slices[i]);
-    }
-  }
   // Report payload.
   {
     MutexLock lock(&subchannel_stream_client_->mu_);
     if (subchannel_stream_client_->event_handler_ != nullptr) {
-      absl::string_view serialized_message(
-          reinterpret_cast<char*>(recv_message), recv_message_buffer_.length);
       absl::Status status =
           subchannel_stream_client_->event_handler_->RecvMessageReadyLocked(
-              subchannel_stream_client_.get(), serialized_message);
+              subchannel_stream_client_.get(), recv_message_->JoinIntoString());
       if (!status.ok()) {
         if (GPR_UNLIKELY(subchannel_stream_client_->tracer_ != nullptr)) {
           gpr_log(GPR_INFO,
@@ -410,7 +390,7 @@ void SubchannelStreamClient::CallState::DoneReadingRecvMessage(
     }
   }
   seen_response_.store(true, std::memory_order_release);
-  grpc_slice_buffer_destroy_internal(&recv_message_buffer_);
+  recv_message_.reset();
   // Start another recv_message batch.
   // This re-uses the ref we're holding.
   // Note: Can't just reuse batch_ here, since we don't know that all
@@ -424,62 +404,11 @@ void SubchannelStreamClient::CallState::DoneReadingRecvMessage(
   StartBatch(&recv_message_batch_);
 }
 
-grpc_error_handle
-SubchannelStreamClient::CallState::PullSliceFromRecvMessage() {
-  grpc_slice slice;
-  grpc_error_handle error = recv_message_->Pull(&slice);
-  if (error == GRPC_ERROR_NONE) {
-    grpc_slice_buffer_add(&recv_message_buffer_, slice);
-  }
-  return error;
-}
-
-void SubchannelStreamClient::CallState::ContinueReadingRecvMessage() {
-  while (recv_message_->Next(SIZE_MAX, &recv_message_ready_)) {
-    grpc_error_handle error = PullSliceFromRecvMessage();
-    if (error != GRPC_ERROR_NONE) {
-      DoneReadingRecvMessage(error);
-      return;
-    }
-    if (recv_message_buffer_.length == recv_message_->length()) {
-      DoneReadingRecvMessage(GRPC_ERROR_NONE);
-      break;
-    }
-  }
-}
-
-void SubchannelStreamClient::CallState::OnByteStreamNext(
-    void* arg, grpc_error_handle error) {
-  auto* self = static_cast<SubchannelStreamClient::CallState*>(arg);
-  if (error != GRPC_ERROR_NONE) {
-    self->DoneReadingRecvMessage(GRPC_ERROR_REF(error));
-    return;
-  }
-  error = self->PullSliceFromRecvMessage();
-  if (error != GRPC_ERROR_NONE) {
-    self->DoneReadingRecvMessage(error);
-    return;
-  }
-  if (self->recv_message_buffer_.length == self->recv_message_->length()) {
-    self->DoneReadingRecvMessage(GRPC_ERROR_NONE);
-  } else {
-    self->ContinueReadingRecvMessage();
-  }
-}
-
 void SubchannelStreamClient::CallState::RecvMessageReady(
     void* arg, grpc_error_handle /*error*/) {
   auto* self = static_cast<SubchannelStreamClient::CallState*>(arg);
   GRPC_CALL_COMBINER_STOP(&self->call_combiner_, "recv_message_ready");
-  if (self->recv_message_ == nullptr) {
-    self->call_->Unref(DEBUG_LOCATION, "recv_message_ready");
-    return;
-  }
-  grpc_slice_buffer_init(&self->recv_message_buffer_);
-  GRPC_CLOSURE_INIT(&self->recv_message_ready_, OnByteStreamNext, self,
-                    grpc_schedule_on_exec_ctx);
-  self->ContinueReadingRecvMessage();
-  // Ref will continue to be held until we finish draining the byte stream.
+  self->RecvMessageReady();
 }
 
 void SubchannelStreamClient::CallState::RecvTrailingMetadataReady(
@@ -491,7 +420,7 @@ void SubchannelStreamClient::CallState::RecvTrailingMetadataReady(
   grpc_status_code status =
       self->recv_trailing_metadata_.get(GrpcStatusMetadata())
           .value_or(GRPC_STATUS_UNKNOWN);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_error_get_status(error, Timestamp::InfFuture(), &status,
                           nullptr /* slice */, nullptr /* http_error */,
                           nullptr /* error_string */);

data/src/core/ext/filters/client_channel/subchannel_stream_client.h

@@ -20,21 +20,33 @@
 #include <grpc/support/port_platform.h>
 
 #include <atomic>
+#include <memory>
 
+#include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include <grpc/event_engine/memory_allocator.h>
+#include <grpc/slice.h>
+#include <grpc/status.h>
 
 #include "src/core/ext/filters/client_channel/subchannel.h"
 #include "src/core/lib/backoff/backoff.h"
+#include "src/core/lib/channel/context.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/resource_quota/arena.h"
-#include "src/core/lib/transport/byte_stream.h"
+#include "src/core/lib/resource_quota/memory_quota.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/transport.h"
 
@@ -120,6 +132,8 @@ class SubchannelStreamClient
     void CallEndedLocked(bool retry)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&subchannel_stream_client_->mu_);
 
+    void RecvMessageReady();
+
     static void OnComplete(void* arg, grpc_error_handle error);
     static void RecvInitialMetadataReady(void* arg, grpc_error_handle error);
     static void RecvMessageReady(void* arg, grpc_error_handle error);
@@ -127,11 +141,6 @@ class SubchannelStreamClient
     static void StartCancel(void* arg, grpc_error_handle error);
     static void OnCancelComplete(void* arg, grpc_error_handle error);
 
-    static void OnByteStreamNext(void* arg, grpc_error_handle error);
-    void ContinueReadingRecvMessage();
-    grpc_error_handle PullSliceFromRecvMessage();
-    void DoneReadingRecvMessage(grpc_error_handle error);
-
     static void AfterCallStackDestruction(void* arg, grpc_error_handle error);
 
     RefCountedPtr<SubchannelStreamClient> subchannel_stream_client_;
@@ -157,7 +166,7 @@ class SubchannelStreamClient
     grpc_metadata_batch send_initial_metadata_;
 
     // send_message
-    absl::optional<SliceBufferByteStream> send_message_;
+    SliceBuffer send_message_;
 
     // send_trailing_metadata
     grpc_metadata_batch send_trailing_metadata_;
@@ -167,9 +176,8 @@ class SubchannelStreamClient
     grpc_closure recv_initial_metadata_ready_;
 
     // recv_message
-    OrphanablePtr<ByteStream> recv_message_;
+    absl::optional<SliceBuffer> recv_message_;
     grpc_closure recv_message_ready_;
-    grpc_slice_buffer recv_message_buffer_;
     std::atomic<bool> seen_response_{false};
 
     // True if the cancel_stream batch has been started.

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

@@ -18,19 +18,24 @@
 
 #include "src/core/ext/filters/deadline/deadline_filter.h"
 
-#include <stdbool.h>
-#include <string.h>
+#include <new>
 
-#include <grpc/support/alloc.h>
+#include "absl/status/status.h"
+#include "absl/types/optional.h"
+
+#include <grpc/status.h>
 #include <grpc/support/log.h>
-#include <grpc/support/sync.h>
-#include <grpc/support/time.h>
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/surface/channel_init.h"
+#include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/transport/metadata_batch.h"
 
 namespace grpc_core {
 
@@ -347,6 +352,7 @@ const grpc_channel_filter grpc_client_deadline_filter = {
     deadline_destroy_call_elem,
     0,  // sizeof(channel_data)
     deadline_init_channel_elem,
+    grpc_channel_stack_no_post_init,
     deadline_destroy_channel_elem,
     grpc_channel_next_get_info,
     "deadline",
@@ -362,6 +368,7 @@ const grpc_channel_filter grpc_server_deadline_filter = {
     deadline_destroy_call_elem,
     0,  // sizeof(channel_data)
     deadline_init_channel_elem,
+    grpc_channel_stack_no_post_init,
     deadline_destroy_channel_elem,
     grpc_channel_next_get_info,
     "deadline",
@@ -380,8 +387,10 @@ void RegisterDeadlineFilter(CoreConfiguration::Builder* builder) {
     builder->channel_init()->RegisterStage(
         type, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
         [filter](ChannelStackBuilder* builder) {
-          if (grpc_deadline_checking_enabled(builder->channel_args())) {
-            builder->PrependFilter(filter, nullptr);
+          auto args = builder->channel_args();
+          if (args.GetBool(GRPC_ARG_ENABLE_DEADLINE_CHECKS)
+                  .value_or(!args.WantMinimalStack())) {
+            builder->PrependFilter(filter);
           }
           return true;
         });

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

@@ -19,8 +19,15 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <grpc/impl/codegen/grpc_types.h>
+
+#include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/call_combiner.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/resource_quota/arena.h"
+#include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 class TimerState;

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

@@ -18,22 +18,40 @@
 
 #include "src/core/ext/filters/fault_injection/fault_injection_filter.h"
 
+#include <stdint.h>
+#include <stdlib.h>
+
+#include <algorithm>
 #include <atomic>
+#include <functional>
+#include <string>
+#include <type_traits>
+#include <utility>
 
+#include "absl/status/status.h"
 #include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "absl/utility/utility.h"
 
 #include <grpc/status.h>
-#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/filters/fault_injection/service_config_parser.h"
 #include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/context.h"
 #include "src/core/lib/channel/status_util.h"
-#include "src/core/lib/gprpp/capture.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/sleep.h"
 #include "src/core/lib/promise/try_seq.h"
 #include "src/core/lib/service_config/service_config_call_data.h"
-#include "src/core/lib/transport/status_conversion.h"
+#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
@@ -136,9 +154,7 @@ ArenaPromise<ServerMetadataHandle> FaultInjectionFilter::MakeCallPromise(
   auto delay = decision.DelayUntil();
   return TrySeq(
       Sleep(delay),
-      Capture(
-          [](InjectionDecision* decision) { return decision->MaybeAbort(); },
-          std::move(decision)),
+      [decision = std::move(decision)]() { return decision.MaybeAbort(); },
       next_promise_factory(std::move(call_args)));
 }
 

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

@@ -19,9 +19,14 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/fault_injection/service_config_parser.h"
-#include "src/core/lib/channel/channel_stack.h"
+#include <stddef.h>
+
+#include "absl/status/statusor.h"
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/promise_based_filter.h"
+#include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/transport/transport.h"
 
 // Channel arg key for enabling parsing fault injection via method config.
@@ -53,7 +58,7 @@ class FaultInjectionFilter : public ChannelFilter {
       const ClientMetadataHandle& initial_metadata);
 
   // The relative index of instances of the same filter.
-  int index_;
+  size_t index_;
   const size_t service_config_parser_index_;
 };
 

data/src/core/ext/filters/fault_injection/service_config_parser.cc

@@ -18,15 +18,18 @@
 
 #include "src/core/ext/filters/fault_injection/service_config_parser.h"
 
+#include <algorithm>
+#include <type_traits>
 #include <vector>
 
+#include "absl/memory/memory.h"
 #include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
+
+#include <grpc/support/log.h>
 
 #include "src/core/ext/filters/fault_injection/fault_injection_filter.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/status_util.h"
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/json/json_util.h"
 
 namespace grpc_core {
@@ -141,7 +144,7 @@ ParseFaultInjectionPolicy(const Json::Array& policies_json_array,
 std::unique_ptr<ServiceConfigParser::ParsedConfig>
 FaultInjectionServiceConfigParser::ParsePerMethodParams(
     const grpc_channel_args* args, const Json& json, grpc_error_handle* error) {
-  GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
+  GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
   // Only parse fault injection policy if the following channel arg is present.
   if (!grpc_channel_args_find_bool(
           args, GRPC_ARG_PARSE_FAULT_INJECTION_METHOD_CONFIG, false)) {
@@ -158,7 +161,7 @@ FaultInjectionServiceConfigParser::ParsePerMethodParams(
         ParseFaultInjectionPolicy(*policies_json_array, &error_list);
   }
   *error = GRPC_ERROR_CREATE_FROM_VECTOR("Fault injection parser", &error_list);
-  if (*error != GRPC_ERROR_NONE || fault_injection_policies.empty()) {
+  if (!GRPC_ERROR_IS_NONE(*error) || fault_injection_policies.empty()) {
     return nullptr;
   }
   return absl::make_unique<FaultInjectionMethodParsedConfig>(

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

@@ -19,10 +19,24 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+#include <stdint.h>
+
+#include <limits>
+#include <memory>
+#include <string>
+#include <utility>
 #include <vector>
 
+#include "absl/strings/string_view.h"
+
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/status.h>
+
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/json/json.h"
 #include "src/core/lib/service_config/service_config_parser.h"
 
 namespace grpc_core {
@@ -58,8 +72,8 @@ class FaultInjectionMethodParsedConfig
   // keep track of their relative positions. The FaultInjectionFilter uses this
   // method to access the parsed fault injection policy in service config,
   // whether it came from xDS resolver or directly from service config
-  const FaultInjectionPolicy* fault_injection_policy(int index) const {
-    if (static_cast<size_t>(index) >= fault_injection_policies_.size()) {
+  const FaultInjectionPolicy* fault_injection_policy(size_t index) const {
+    if (index >= fault_injection_policies_.size()) {
       return nullptr;
     }
     return &fault_injection_policies_[index];

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

@@ -19,24 +19,36 @@
 
 #include "src/core/ext/filters/http/client/http_client_filter.h"
 
-#include <stdint.h>
-#include <string.h>
-
+#include <algorithm>
+#include <functional>
 #include <string>
+#include <utility>
 #include <vector>
 
+#include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "absl/utility/utility.h"
 
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
+#include <grpc/grpc.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/status.h>
 
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/promise/call_push_pull.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/poll.h"
 #include "src/core/lib/promise/seq.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"
+#include "src/core/lib/transport/transport_fwd.h"
 #include "src/core/lib/transport/transport_impl.h"
 
 namespace grpc_core {
@@ -97,7 +109,11 @@ Slice UserAgentFromArgs(const ChannelArgs& args, const char* transport_name) {
 ArenaPromise<ServerMetadataHandle> HttpClientFilter::MakeCallPromise(
     CallArgs call_args, NextPromiseFactory next_promise_factory) {
   auto& md = call_args.client_initial_metadata;
-  md->Set(HttpMethodMetadata(), HttpMethodMetadata::kPost);
+  if (test_only_use_put_requests_) {
+    md->Set(HttpMethodMetadata(), HttpMethodMetadata::kPut);
+  } else {
+    md->Set(HttpMethodMetadata(), HttpMethodMetadata::kPost);
+  }
   md->Set(HttpSchemeMetadata(), scheme_);
   md->Set(TeMetadata(), TeMetadata::kTrailers);
   md->Set(ContentTypeMetadata(), ContentTypeMetadata::kApplicationGrpc);
@@ -125,8 +141,11 @@ ArenaPromise<ServerMetadataHandle> HttpClientFilter::MakeCallPromise(
 }
 
 HttpClientFilter::HttpClientFilter(HttpSchemeMetadata::ValueType scheme,
-                                   Slice user_agent)
-    : scheme_(scheme), user_agent_(std::move(user_agent)) {}
+                                   Slice user_agent,
+                                   bool test_only_use_put_requests)
+    : scheme_(scheme),
+      user_agent_(std::move(user_agent)),
+      test_only_use_put_requests_(test_only_use_put_requests) {}
 
 absl::StatusOr<HttpClientFilter> HttpClientFilter::Create(ChannelArgs args,
                                                           ChannelFilter::Args) {
@@ -134,8 +153,9 @@ absl::StatusOr<HttpClientFilter> HttpClientFilter::Create(ChannelArgs args,
   if (transport == nullptr) {
     return absl::InvalidArgumentError("HttpClientFilter needs a transport");
   }
-  return HttpClientFilter(SchemeFromArgs(args),
-                          UserAgentFromArgs(args, transport->vtable->name));
+  return HttpClientFilter(
+      SchemeFromArgs(args), UserAgentFromArgs(args, transport->vtable->name),
+      args.GetInt(GRPC_ARG_TEST_ONLY_USE_PUT_REQUESTS).value_or(false));
 }
 
 }  // namespace grpc_core

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

@@ -20,8 +20,15 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/channel/channel_stack.h"
+#include "absl/status/statusor.h"
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/promise_based_filter.h"
+#include "src/core/lib/promise/arena_promise.h"
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 
@@ -37,12 +44,18 @@ class HttpClientFilter : public ChannelFilter {
       CallArgs call_args, NextPromiseFactory next_promise_factory) override;
 
  private:
-  HttpClientFilter(HttpSchemeMetadata::ValueType scheme, Slice user_agent);
+  HttpClientFilter(HttpSchemeMetadata::ValueType scheme, Slice user_agent,
+                   bool test_only_use_put_requests);
 
   HttpSchemeMetadata::ValueType scheme_;
   Slice user_agent_;
+  bool test_only_use_put_requests_;
 };
 
+// A test-only channel arg to allow testing gRPC Core server behavior on PUT
+// requests.
+#define GRPC_ARG_TEST_ONLY_USE_PUT_REQUESTS "grpc.testing.use_put_requests"
+
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_EXT_FILTERS_HTTP_CLIENT_HTTP_CLIENT_FILTER_H */