grpc 1.48.0 → 1.50.0

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

@@ -23,9 +23,11 @@
 
 #include <string>
 
-#include <grpc/impl/codegen/grpc_types.h>
+#include "absl/strings/string_view.h"
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/resolved_address.h"
@@ -39,34 +41,24 @@ extern TraceFlag grpc_subchannel_pool_trace;
 // A key that can uniquely identify a subchannel.
 class SubchannelKey {
  public:
-  SubchannelKey(const grpc_resolved_address& address,
-                const grpc_channel_args* args);
-  ~SubchannelKey();
+  SubchannelKey(const grpc_resolved_address& address, const ChannelArgs& args);
 
-  // Copyable.
-  SubchannelKey(const SubchannelKey& other);
-  SubchannelKey& operator=(const SubchannelKey& other);
-  // Movable
-  SubchannelKey(SubchannelKey&&) noexcept;
-  SubchannelKey& operator=(SubchannelKey&&) noexcept;
+  SubchannelKey(const SubchannelKey& other) = default;
+  SubchannelKey& operator=(const SubchannelKey& other) = default;
+  SubchannelKey(SubchannelKey&& other) noexcept = default;
+  SubchannelKey& operator=(SubchannelKey&& other) noexcept = default;
 
   bool operator<(const SubchannelKey& other) const;
 
   const grpc_resolved_address& address() const { return address_; }
-  const grpc_channel_args* args() const { return args_; }
+  const ChannelArgs& args() const { return args_; }
 
   // Human-readable string suitable for logging.
   std::string ToString() const;
 
  private:
-  // Initializes the subchannel key with the given \a args and the function to
-  // copy channel args.
-  void Init(
-      const grpc_resolved_address& address, const grpc_channel_args* args,
-      grpc_channel_args* (*copy_channel_args)(const grpc_channel_args* args));
-
   grpc_resolved_address address_;
-  const grpc_channel_args* args_;
+  ChannelArgs args_;
 };
 
 // Interface for subchannel pool.
@@ -81,6 +73,12 @@ class SubchannelPoolInterface : public RefCounted<SubchannelPoolInterface> {
                        : nullptr) {}
   ~SubchannelPoolInterface() override {}
 
+  static absl::string_view ChannelArgName();
+  static int ChannelArgsCompare(const SubchannelPoolInterface* a,
+                                const SubchannelPoolInterface* b) {
+    return QsortCompare(a, b);
+  }
+
   // Registers a subchannel against a key. Returns the subchannel registered
   // with \a key, which may be different from \a constructed because we reuse
   // (instead of update) any existing subchannel already registered with \a key.
@@ -95,13 +93,6 @@ class SubchannelPoolInterface : public RefCounted<SubchannelPoolInterface> {
   // if no such channel exists. Thread-safe.
   virtual RefCountedPtr<Subchannel> FindSubchannel(
       const SubchannelKey& key) = 0;
-
-  // Creates a channel arg from \a subchannel pool.
-  static grpc_arg CreateChannelArg(SubchannelPoolInterface* subchannel_pool);
-
-  // Gets the subchannel pool from the channel args.
-  static SubchannelPoolInterface* GetSubchannelPoolFromChannelArgs(
-      const grpc_channel_args* args);
 };
 
 }  // namespace grpc_core

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

@@ -27,12 +27,11 @@
 #include <grpc/status.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/channel/channel_args.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/resource_quota/resource_quota.h"
 #include "src/core/lib/transport/error_utils.h"
 
@@ -56,7 +55,8 @@ SubchannelStreamClient::SubchannelStreamClient(
       interested_parties_(interested_parties),
       tracer_(tracer),
       call_allocator_(
-          ResourceQuotaFromChannelArgs(connected_subchannel_->args())
+          connected_subchannel_->args()
+              .GetObject<ResourceQuota>()
               ->memory_quota()
               ->CreateMemoryAllocator(
                   (tracer != nullptr) ? tracer : "SubchannelStreamClient")),
@@ -127,7 +127,7 @@ void SubchannelStreamClient::StartRetryTimerLocked() {
   if (GPR_UNLIKELY(tracer_ != nullptr)) {
     gpr_log(GPR_INFO, "%s %p: SubchannelStreamClient health check call lost...",
             tracer_, this);
-    Duration timeout = next_try - ExecCtx::Get()->Now();
+    Duration timeout = next_try - Timestamp::Now();
     if (timeout > Duration::Zero()) {
       gpr_log(GPR_INFO, "%s %p: ... will retry in %" PRId64 "ms.", tracer_,
               this, timeout.millis());
@@ -243,7 +243,6 @@ void SubchannelStreamClient::CallState::StartCallLocked() {
   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.
@@ -258,7 +257,6 @@ void SubchannelStreamClient::CallState::StartCallLocked() {
   // Add recv_initial_metadata op.
   payload_.recv_initial_metadata.recv_initial_metadata =
       &recv_initial_metadata_;
-  payload_.recv_initial_metadata.recv_flags = nullptr;
   payload_.recv_initial_metadata.trailing_metadata_available = nullptr;
   payload_.recv_initial_metadata.peer_string = nullptr;
   // recv_initial_metadata_ready callback takes ref, handled manually.

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

@@ -23,6 +23,7 @@
 #include "absl/status/status.h"
 #include "absl/types/optional.h"
 
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/status.h>
 #include <grpc/support/log.h>
 
@@ -374,10 +375,10 @@ const grpc_channel_filter grpc_server_deadline_filter = {
     "deadline",
 };
 
-bool grpc_deadline_checking_enabled(const grpc_channel_args* channel_args) {
-  return grpc_channel_arg_get_bool(
-      grpc_channel_args_find(channel_args, GRPC_ARG_ENABLE_DEADLINE_CHECKS),
-      !grpc_channel_args_want_minimal_stack(channel_args));
+bool grpc_deadline_checking_enabled(
+    const grpc_core::ChannelArgs& channel_args) {
+  return channel_args.GetBool(GRPC_ARG_ENABLE_DEADLINE_CHECKS)
+      .value_or(!channel_args.WantMinimalStack());
 }
 
 namespace grpc_core {
@@ -388,8 +389,7 @@ void RegisterDeadlineFilter(CoreConfiguration::Builder* builder) {
         type, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
         [filter](ChannelStackBuilder* builder) {
           auto args = builder->channel_args();
-          if (args.GetBool(GRPC_ARG_ENABLE_DEADLINE_CHECKS)
-                  .value_or(!args.WantMinimalStack())) {
+          if (grpc_deadline_checking_enabled(args)) {
             builder->PrependFilter(filter);
           }
           return true;

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

@@ -19,8 +19,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/impl/codegen/grpc_types.h>
-
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/gprpp/time.h"
@@ -83,7 +82,7 @@ void grpc_deadline_state_client_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* op);
 
 // Should deadline checking be performed (according to channel args)
-bool grpc_deadline_checking_enabled(const grpc_channel_args* args);
+bool grpc_deadline_checking_enabled(const grpc_core::ChannelArgs& args);
 
 // Deadline filters for direct client channels and server channels.
 // Note: Deadlines for non-direct client channels are handled by the

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

@@ -19,13 +19,11 @@
 #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"
@@ -33,7 +31,6 @@
 #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/log.h>
@@ -45,9 +42,7 @@
 #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"
@@ -72,12 +67,14 @@ auto AsInt(absl::string_view s) -> absl::optional<T> {
   return absl::nullopt;
 }
 
-inline bool UnderFraction(const uint32_t numerator,
+inline bool UnderFraction(absl::InsecureBitGen* rand_generator,
+                          const uint32_t numerator,
                           const uint32_t denominator) {
   if (numerator <= 0) return false;
   if (numerator >= denominator) return true;
   // Generate a random number in [0, denominator).
-  const uint32_t random_number = rand() % denominator;
+  const uint32_t random_number =
+      absl::Uniform(absl::IntervalClosedOpen, *rand_generator, 0u, denominator);
   return random_number < numerator;
 }
 
@@ -98,7 +95,7 @@ class FaultHandle {
   FaultHandle(const FaultHandle&) = delete;
   FaultHandle& operator=(const FaultHandle&) = delete;
   FaultHandle(FaultHandle&& other) noexcept
-      : active_(absl::exchange(other.active_, false)) {}
+      : active_(std::exchange(other.active_, false)) {}
   FaultHandle& operator=(FaultHandle&& other) noexcept {
     std::swap(active_, other.active_);
     return *this;
@@ -132,7 +129,7 @@ class FaultInjectionFilter::InjectionDecision {
 };
 
 absl::StatusOr<FaultInjectionFilter> FaultInjectionFilter::Create(
-    ChannelArgs, ChannelFilter::Args filter_args) {
+    const ChannelArgs&, ChannelFilter::Args filter_args) {
   return FaultInjectionFilter(filter_args);
 }
 
@@ -141,7 +138,8 @@ FaultInjectionFilter::FaultInjectionFilter(ChannelFilter::Args filter_args)
           filter_args.channel_stack(),
           filter_args.uninitialized_channel_element())),
       service_config_parser_index_(
-          FaultInjectionServiceConfigParser::ParserIndex()) {}
+          FaultInjectionServiceConfigParser::ParserIndex()),
+      mu_(new Mutex) {}
 
 // Construct a promise for one call.
 ArenaPromise<ServerMetadataHandle> FaultInjectionFilter::MakeCallPromise(
@@ -221,14 +219,21 @@ FaultInjectionFilter::MakeInjectionDecision(
     }
   }
   // Roll the dice
-  const bool delay_request =
-      delay != Duration::Zero() &&
-      UnderFraction(delay_percentage_numerator,
-                    fi_policy->delay_percentage_denominator);
-  const bool abort_request =
-      abort_code != GRPC_STATUS_OK &&
-      UnderFraction(abort_percentage_numerator,
-                    fi_policy->abort_percentage_denominator);
+  bool delay_request = delay != Duration::Zero();
+  bool abort_request = abort_code != GRPC_STATUS_OK;
+  if (delay_request || abort_request) {
+    MutexLock lock(mu_.get());
+    if (delay_request) {
+      delay_request =
+          UnderFraction(&delay_rand_generator_, delay_percentage_numerator,
+                        fi_policy->delay_percentage_denominator);
+    }
+    if (abort_request) {
+      abort_request =
+          UnderFraction(&abort_rand_generator_, abort_percentage_numerator,
+                        fi_policy->abort_percentage_denominator);
+    }
+  }
 
   return InjectionDecision(
       fi_policy->max_faults, delay_request ? delay : Duration::Zero(),
@@ -245,7 +250,7 @@ bool FaultInjectionFilter::InjectionDecision::HaveActiveFaultsQuota() const {
 Timestamp FaultInjectionFilter::InjectionDecision::DelayUntil() {
   if (delay_time_ != Duration::Zero() && HaveActiveFaultsQuota()) {
     active_fault_ = FaultHandle{true};
-    return ExecCtx::Get()->Now() + delay_time_;
+    return Timestamp::Now() + delay_time_;
   }
   return Timestamp::InfPast();
 }

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

@@ -21,11 +21,16 @@
 
 #include <stddef.h>
 
+#include <memory>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/random/random.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/gprpp/sync.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/transport/transport.h"
 
@@ -44,7 +49,7 @@ class FaultInjectionFilter : public ChannelFilter {
   static const grpc_channel_filter kFilter;
 
   static absl::StatusOr<FaultInjectionFilter> Create(
-      ChannelArgs args, ChannelFilter::Args filter_args);
+      const ChannelArgs& args, ChannelFilter::Args filter_args);
 
   // Construct a promise for one call.
   ArenaPromise<ServerMetadataHandle> MakeCallPromise(
@@ -60,6 +65,9 @@ class FaultInjectionFilter : public ChannelFilter {
   // The relative index of instances of the same filter.
   size_t index_;
   const size_t service_config_parser_index_;
+  std::unique_ptr<Mutex> mu_;
+  absl::InsecureBitGen abort_rand_generator_ ABSL_GUARDED_BY(mu_);
+  absl::InsecureBitGen delay_rand_generator_ ABSL_GUARDED_BY(mu_);
 };
 
 }  // namespace grpc_core

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

@@ -19,17 +19,17 @@
 #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/status/status.h"
 #include "absl/strings/str_cat.h"
-
-#include <grpc/support/log.h>
+#include "absl/types/optional.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/iomgr/error.h"
 #include "src/core/lib/json/json_util.h"
 
 namespace grpc_core {
@@ -141,13 +141,12 @@ ParseFaultInjectionPolicy(const Json::Array& policies_json_array,
 
 }  // namespace
 
-std::unique_ptr<ServiceConfigParser::ParsedConfig>
-FaultInjectionServiceConfigParser::ParsePerMethodParams(
-    const grpc_channel_args* args, const Json& json, grpc_error_handle* error) {
-  GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
+absl::StatusOr<std::unique_ptr<ServiceConfigParser::ParsedConfig>>
+FaultInjectionServiceConfigParser::ParsePerMethodParams(const ChannelArgs& args,
+                                                        const Json& json) {
   // 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)) {
+  if (!args.GetBool(GRPC_ARG_PARSE_FAULT_INJECTION_METHOD_CONFIG)
+           .value_or(false)) {
     return nullptr;
   }
   // Parse fault injection policy from given Json
@@ -160,10 +159,16 @@ FaultInjectionServiceConfigParser::ParsePerMethodParams(
     fault_injection_policies =
         ParseFaultInjectionPolicy(*policies_json_array, &error_list);
   }
-  *error = GRPC_ERROR_CREATE_FROM_VECTOR("Fault injection parser", &error_list);
-  if (!GRPC_ERROR_IS_NONE(*error) || fault_injection_policies.empty()) {
-    return nullptr;
+  if (!error_list.empty()) {
+    grpc_error_handle error =
+        GRPC_ERROR_CREATE_FROM_VECTOR("Fault injection parser", &error_list);
+    absl::Status status = absl::InvalidArgumentError(
+        absl::StrCat("error parsing fault injection method parameters: ",
+                     grpc_error_std_string(error)));
+    GRPC_ERROR_UNREF(error);
+    return status;
   }
+  if (fault_injection_policies.empty()) return nullptr;
   return absl::make_unique<FaultInjectionMethodParsedConfig>(
       std::move(fault_injection_policies));
 }

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

@@ -28,14 +28,14 @@
 #include <utility>
 #include <vector>
 
+#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/status.h>
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.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"
 
@@ -88,9 +88,8 @@ class FaultInjectionServiceConfigParser final
  public:
   absl::string_view name() const override { return parser_name(); }
   // Parses the per-method service config for fault injection filter.
-  std::unique_ptr<ServiceConfigParser::ParsedConfig> ParsePerMethodParams(
-      const grpc_channel_args* args, const Json& json,
-      grpc_error_handle* error) override;
+  absl::StatusOr<std::unique_ptr<ServiceConfigParser::ParsedConfig>>
+  ParsePerMethodParams(const ChannelArgs& args, const Json& json) override;
   // Returns the parser index for FaultInjectionServiceConfigParser.
   static size_t ParserIndex();
   // Registers FaultInjectionServiceConfigParser to ServiceConfigParser.

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

@@ -31,7 +31,6 @@
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
-#include "absl/utility/utility.h"
 
 #include <grpc/grpc.h>
 #include <grpc/impl/codegen/grpc_types.h>
@@ -43,7 +42,6 @@
 #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"
@@ -121,7 +119,7 @@ ArenaPromise<ServerMetadataHandle> HttpClientFilter::MakeCallPromise(
 
   auto* read_latch = GetContext<Arena>()->New<Latch<ServerMetadata*>>();
   auto* write_latch =
-      absl::exchange(call_args.server_initial_metadata, read_latch);
+      std::exchange(call_args.server_initial_metadata, read_latch);
 
   return CallPushPull(
       Seq(next_promise_factory(std::move(call_args)),
@@ -147,8 +145,8 @@ HttpClientFilter::HttpClientFilter(HttpSchemeMetadata::ValueType 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) {
+absl::StatusOr<HttpClientFilter> HttpClientFilter::Create(
+    const ChannelArgs& args, ChannelFilter::Args) {
   auto* transport = args.GetObject<grpc_transport>();
   if (transport == nullptr) {
     return absl::InvalidArgumentError("HttpClientFilter needs a transport");

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

@@ -37,7 +37,7 @@ class HttpClientFilter : public ChannelFilter {
   static const grpc_channel_filter kFilter;
 
   static absl::StatusOr<HttpClientFilter> Create(
-      ChannelArgs args, ChannelFilter::Args filter_args);
+      const ChannelArgs& args, ChannelFilter::Args filter_args);
 
   // Construct a promise for one call.
   ArenaPromise<ServerMetadataHandle> MakeCallPromise(

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

@@ -33,7 +33,6 @@
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/promise/poll.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"
@@ -41,7 +40,7 @@
 namespace grpc_core {
 
 absl::StatusOr<ClientAuthorityFilter> ClientAuthorityFilter::Create(
-    ChannelArgs args, ChannelFilter::Args) {
+    const ChannelArgs& args, ChannelFilter::Args) {
   absl::optional<absl::string_view> default_authority =
       args.GetString(GRPC_ARG_DEFAULT_AUTHORITY);
   if (!default_authority.has_value()) {

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

@@ -38,7 +38,7 @@ class ClientAuthorityFilter final : public ChannelFilter {
  public:
   static const grpc_channel_filter kFilter;
 
-  static absl::StatusOr<ClientAuthorityFilter> Create(ChannelArgs args,
+  static absl::StatusOr<ClientAuthorityFilter> Create(const ChannelArgs& args,
                                                       ChannelFilter::Args);
 
   // Construct a promise for one call.

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

@@ -24,10 +24,10 @@
 #include <stdlib.h>
 
 #include <new>
+#include <utility>
 
 #include "absl/meta/type_traits.h"
 #include "absl/types/optional.h"
-#include "absl/utility/utility.h"
 
 #include <grpc/compression.h>
 #include <grpc/impl/codegen/compression_types.h>
@@ -40,7 +40,6 @@
 #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/profiling/timers.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/transport/metadata_batch.h"
@@ -204,7 +203,7 @@ void CallData::FinishSendMessage(grpc_call_element* elem) {
       }
     }
   }
-  grpc_call_next_op(elem, absl::exchange(send_message_batch_, nullptr));
+  grpc_call_next_op(elem, std::exchange(send_message_batch_, nullptr));
 }
 
 void CallData::FailSendMessageBatchInCallCombiner(void* calld_arg,
@@ -227,7 +226,6 @@ void CallData::ForwardSendMessageBatch(void* elem_arg,
 
 void CallData::CompressStartTransportStreamOpBatch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
-  GPR_TIMER_SCOPE("compress_start_transport_stream_op_batch", 0);
   // Handle cancel_stream.
   if (batch->cancel_stream) {
     GRPC_ERROR_UNREF(cancel_error_);

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

@@ -40,7 +40,6 @@
 #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/profiling/timers.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
@@ -274,7 +273,6 @@ void CallData::DecompressStartTransportStreamOpBatch(
 
 void DecompressStartTransportStreamOpBatch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
-  GPR_TIMER_SCOPE("decompress_start_transport_stream_op_batch", 0);
   CallData* calld = static_cast<CallData*>(elem->call_data);
   calld->DecompressStartTransportStreamOpBatch(elem, batch);
 }

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

@@ -26,7 +26,6 @@
 #include "absl/base/attributes.h"
 #include "absl/status/status.h"
 #include "absl/types/optional.h"
-#include "absl/utility/utility.h"
 
 #include <grpc/impl/codegen/grpc_types.h>
 
@@ -36,7 +35,6 @@
 #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/promise.h"
 #include "src/core/lib/promise/seq.h"
 #include "src/core/lib/resource_quota/arena.h"
@@ -131,7 +129,7 @@ ArenaPromise<ServerMetadataHandle> HttpServerFilter::MakeCallPromise(
 
   auto* read_latch = GetContext<Arena>()->New<Latch<ServerMetadata*>>();
   auto* write_latch =
-      absl::exchange(call_args.server_initial_metadata, read_latch);
+      std::exchange(call_args.server_initial_metadata, read_latch);
 
   return CallPushPull(Seq(next_promise_factory(std::move(call_args)),
                           [](ServerMetadataHandle md) -> ServerMetadataHandle {
@@ -150,8 +148,8 @@ ArenaPromise<ServerMetadataHandle> HttpServerFilter::MakeCallPromise(
                       []() { return absl::OkStatus(); });
 }
 
-absl::StatusOr<HttpServerFilter> HttpServerFilter::Create(ChannelArgs args,
-                                                          ChannelFilter::Args) {
+absl::StatusOr<HttpServerFilter> HttpServerFilter::Create(
+    const ChannelArgs& args, ChannelFilter::Args) {
   return HttpServerFilter(
       args.GetBool(GRPC_ARG_SURFACE_USER_AGENT).value_or(true),
       args.GetBool(

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

@@ -37,7 +37,7 @@ class HttpServerFilter : public ChannelFilter {
   static const grpc_channel_filter kFilter;
 
   static absl::StatusOr<HttpServerFilter> Create(
-      ChannelArgs args, ChannelFilter::Args filter_args);
+      const ChannelArgs& args, ChannelFilter::Args filter_args);
 
   // Construct a promise for one call.
   ArenaPromise<ServerMetadataHandle> MakeCallPromise(

data/src/core/ext/filters/message_size/message_size_filter.cc

@@ -26,6 +26,8 @@
 #include <vector>
 
 #include "absl/memory/memory.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/types/optional.h"
 
@@ -41,6 +43,7 @@
 #include "src/core/lib/gprpp/debug_location.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/service_config/service_config_call_data.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/surface/channel_init.h"
@@ -72,11 +75,9 @@ const MessageSizeParsedConfig* MessageSizeParsedConfig::GetFromCallContext(
 // MessageSizeParser
 //
 
-std::unique_ptr<ServiceConfigParser::ParsedConfig>
-MessageSizeParser::ParsePerMethodParams(const grpc_channel_args* /*args*/,
-                                        const Json& json,
-                                        grpc_error_handle* error) {
-  GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
+absl::StatusOr<std::unique_ptr<ServiceConfigParser::ParsedConfig>>
+MessageSizeParser::ParsePerMethodParams(const ChannelArgs& /*args*/,
+                                        const Json& json) {
   std::vector<grpc_error_handle> error_list;
   // Max request size.
   int max_request_message_bytes = -1;
@@ -113,8 +114,13 @@ MessageSizeParser::ParsePerMethodParams(const grpc_channel_args* /*args*/,
     }
   }
   if (!error_list.empty()) {
-    *error = GRPC_ERROR_CREATE_FROM_VECTOR("Message size parser", &error_list);
-    return nullptr;
+    grpc_error_handle error =
+        GRPC_ERROR_CREATE_FROM_VECTOR("Message size parser", &error_list);
+    absl::Status status = absl::InvalidArgumentError(
+        absl::StrCat("error parsing message size method parameters: ",
+                     grpc_error_std_string(error)));
+    GRPC_ERROR_UNREF(error);
+    return status;
   }
   return absl::make_unique<MessageSizeParsedConfig>(max_request_message_bytes,
                                                     max_response_message_bytes);