grpc 1.60.0 → 1.61.0

data/include/grpc/event_engine/event_engine.h

@@ -79,7 +79,7 @@ namespace experimental {
 ///
 ///
 /// Blocking EventEngine Callbacks
-/// -----------------------------
+/// ------------------------------
 ///
 /// Doing blocking work in EventEngine callbacks is generally not advisable.
 /// While gRPC's default EventEngine implementations have some capacity to scale
@@ -90,6 +90,15 @@ namespace experimental {
 /// *Best Practice* : Occasional blocking work may be fine, but we do not
 /// recommend running a mostly blocking workload in EventEngine threads.
 ///
+///
+/// Thread-safety guarantees
+/// ------------------------
+///
+/// All EventEngine methods are guaranteed to be thread-safe, no external
+/// synchronization is required to call any EventEngine method. Please note that
+/// this does not apply to application callbacks, which may be run concurrently;
+/// application state synchronization must be managed by the application.
+///
 ////////////////////////////////////////////////////////////////////////////////
 class EventEngine : public std::enable_shared_from_this<EventEngine> {
  public:
@@ -246,6 +255,45 @@ class EventEngine : public std::enable_shared_from_this<EventEngine> {
     /// values are expected to remain valid for the life of the Endpoint.
     virtual const ResolvedAddress& GetPeerAddress() const = 0;
     virtual const ResolvedAddress& GetLocalAddress() const = 0;
+
+    /// A method which allows users to query whether an Endpoint implementation
+    /// supports a specified extension. The name of the extension is provided
+    /// as an input.
+    ///
+    /// An extension could be any type with a unique string id. Each extension
+    /// may support additional capabilities and if the Endpoint implementation
+    /// supports the queried extension, it should return a valid pointer to the
+    /// extension type.
+    ///
+    /// E.g., use case of an EventEngine::Endpoint supporting a custom
+    /// extension.
+    ///
+    /// class CustomEndpointExtension {
+    ///  public:
+    ///    static constexpr std::string name = "my.namespace.extension_name";
+    ///    void Process() { ... }
+    /// }
+    ///
+    ///
+    /// class CustomEndpoint :
+    ///        public EventEngine::Endpoint, CustomEndpointExtension {
+    ///   public:
+    ///     void* QueryExtension(absl::string_view id) override {
+    ///       if (id == CustomEndpointExtension::name) {
+    ///         return static_cast<CustomEndpointExtension*>(this);
+    ///       }
+    ///       return nullptr;
+    ///     }
+    ///     ...
+    /// }
+    ///
+    /// auto ext_ =
+    /// static_cast<CustomEndpointExtension*>(
+    ///   endpoint->QueryExtension(CustomrEndpointExtension::name));
+    /// if (ext_ != nullptr) { ext_->Process(); }
+    ///
+    ///
+    virtual void* QueryExtension(absl::string_view /*id*/) { return nullptr; }
   };
 
   /// Called when a new connection is established.
@@ -405,8 +453,8 @@ class EventEngine : public std::enable_shared_from_this<EventEngine> {
 
   /// Asynchronously executes a task as soon as possible.
   ///
-  /// \a Closures scheduled with \a Run cannot be cancelled. The \a closure will
-  /// not be deleted after it has been run, ownership remains with the caller.
+  /// \a Closures passed to \a Run cannot be cancelled. The \a closure will not
+  /// be deleted after it has been run, ownership remains with the caller.
   ///
   /// Implementations must not execute the closure in the calling thread before
   /// \a Run returns. For example, if the caller must release a lock before the
@@ -415,9 +463,9 @@ class EventEngine : public std::enable_shared_from_this<EventEngine> {
   virtual void Run(Closure* closure) = 0;
   /// Asynchronously executes a task as soon as possible.
   ///
-  /// \a Closures scheduled with \a Run cannot be cancelled. Unlike the
-  /// overloaded \a Closure alternative, the absl::AnyInvocable version's \a
-  /// closure will be deleted by the EventEngine after the closure has been run.
+  /// \a Closures passed to \a Run cannot be cancelled. Unlike the overloaded \a
+  /// Closure alternative, the absl::AnyInvocable version's \a closure will be
+  /// deleted by the EventEngine after the closure has been run.
   ///
   /// This version of \a Run may be less performant than the \a Closure version
   /// in some scenarios. This overload is useful in situations where performance
@@ -453,13 +501,12 @@ class EventEngine : public std::enable_shared_from_this<EventEngine> {
                               absl::AnyInvocable<void()> closure) = 0;
   /// Request cancellation of a task.
   ///
-  /// If the associated closure has already been scheduled to run, it will not
-  /// be cancelled, and this function will return false.
+  /// If the associated closure cannot be cancelled for any reason, this
+  /// function will return false.
   ///
-  /// If the associated closure has not been scheduled to run, it will be
-  /// cancelled, and this method will return true. The associated
-  /// absl::AnyInvocable or \a Closure* will not be called. If the closure type
-  /// was an absl::AnyInvocable, it will be destroyed before the method returns.
+  /// If the associated closure can be cancelled, the associated callback will
+  /// never be run, and this method will return true. If the callback type was
+  /// an absl::AnyInvocable, it will be destroyed before the method returns.
   virtual bool Cancel(TaskHandle handle) = 0;
 };
 

data/include/grpc/event_engine/internal/memory_allocator_impl.h

@@ -50,6 +50,12 @@ class MemoryAllocatorImpl
   /// request.max() inclusively.
   virtual size_t Reserve(MemoryRequest request) = 0;
 
+  /// Allocate a slice, using MemoryRequest to size the number of returned
+  /// bytes. For a variable length request, check the returned slice length to
+  /// verify how much memory was allocated. Takes care of reserving memory for
+  /// any relevant control structures also.
+  virtual grpc_slice MakeSlice(MemoryRequest request) = 0;
+
   /// Release some bytes that were previously reserved.
   /// If more bytes are released than were reserved, we will have undefined
   /// behavior.

data/include/grpc/event_engine/internal/slice_cast.h

@@ -60,6 +60,18 @@ Result& SliceCast(T& value, SliceCastable<Result, T> = {}) {
   return reinterpret_cast<Result&>(value);
 }
 
+// Cast to `Result&&` from `T&&` without any runtime checks.
+// This is only valid if `sizeof(Result) == sizeof(T)`, and if `Result`, `T` are
+// opted in as compatible via `SliceCastable`.
+template <typename Result, typename T>
+Result&& SliceCast(T&& value, SliceCastable<Result, T> = {}) {
+  // Insist upon sizes being equal to catch mismatches.
+  // We assume if sizes are opted in and sizes are equal then yes, these two
+  // types are expected to be layout compatible and actually appear to be.
+  static_assert(sizeof(Result) == sizeof(T), "size mismatch");
+  return reinterpret_cast<Result&&>(value);
+}
+
 }  // namespace internal
 }  // namespace experimental
 }  // namespace grpc_event_engine

data/include/grpc/event_engine/memory_allocator.h

@@ -134,7 +134,9 @@ class MemoryAllocator {
   /// bytes. For a variable length request, check the returned slice length to
   /// verify how much memory was allocated. Takes care of reserving memory for
   /// any relevant control structures also.
-  grpc_slice MakeSlice(MemoryRequest request);
+  grpc_slice MakeSlice(MemoryRequest request) {
+    return allocator_->MakeSlice(request);
+  }
 
   /// A C++ allocator for containers of T.
   template <typename T>

data/include/grpc/event_engine/slice.h

@@ -169,6 +169,11 @@ struct CopyConstructors {
     return Out(grpc_slice_from_copied_buffer(p, len));
   }
 
+  static Out FromCopiedBuffer(const uint8_t* p, size_t len) {
+    return Out(
+        grpc_slice_from_copied_buffer(reinterpret_cast<const char*>(p), len));
+  }
+
   template <typename Buffer>
   static Out FromCopiedBuffer(const Buffer& buffer) {
     return FromCopiedBuffer(reinterpret_cast<const char*>(buffer.data()),

data/include/grpc/grpc_security.h

@@ -815,6 +815,24 @@ GRPCAPI void grpc_tls_certificate_provider_release(
  */
 GRPCAPI grpc_tls_credentials_options* grpc_tls_credentials_options_create(void);
 
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Sets the minimum TLS version that will be negotiated during the TLS
+ * handshake. If not set, the underlying SSL library will set it to TLS v1.2.
+ */
+GRPCAPI void grpc_tls_credentials_options_set_min_tls_version(
+    grpc_tls_credentials_options* options, grpc_tls_version min_tls_version);
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Sets the maximum TLS version that will be negotiated during the TLS
+ * handshake. If not set, the underlying SSL library will set it to TLS v1.3.
+ */
+GRPCAPI void grpc_tls_credentials_options_set_max_tls_version(
+    grpc_tls_credentials_options* options, grpc_tls_version max_tls_version);
+
 /**
  * EXPERIMENTAL API - Subject to change
  *
@@ -894,7 +912,10 @@ GRPCAPI void grpc_tls_credentials_options_set_identity_cert_name(
 GRPCAPI void grpc_tls_credentials_options_set_cert_request_type(
     grpc_tls_credentials_options* options,
     grpc_ssl_client_certificate_request_type type);
-/**
+
+/** Deprecated in favor of grpc_tls_credentials_options_set_crl_provider. The
+ * crl provider interface provides a significantly more flexible approach to
+ * using CRLs. See gRFC A69 for details.
  * EXPERIMENTAL API - Subject to change
  *
  * If set, gRPC will read all hashed x.509 CRL files in the directory and

data/include/grpc/impl/call.h

@@ -0,0 +1,29 @@
+// Copyright 2023 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_IMPL_CALL_H
+#define GRPC_IMPL_CALL_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/functional/any_invocable.h"
+
+#include <grpc/grpc.h>
+
+// Run a callback in the call's EventEngine.
+// Internal-only
+void grpc_call_run_in_event_engine(const grpc_call* call,
+                                   absl::AnyInvocable<void()> cb);
+
+#endif /* GRPC_IMPL_CALL_H */

data/include/grpc/impl/channel_arg_names.h

@@ -15,7 +15,7 @@
 #ifndef GRPC_IMPL_CHANNEL_ARG_NAMES_H
 #define GRPC_IMPL_CHANNEL_ARG_NAMES_H
 
-// IWYU pragma: private, include "third_party/grpc/include/grpc/grpc.h"
+// IWYU pragma: private, include <grpc/grpc.h>
 // IWYU pragma: friend "src/.*"
 // IWYU pragma: friend "test/.*"
 
@@ -106,6 +106,12 @@
  */
 #define GRPC_ARG_HTTP2_MIN_RECV_PING_INTERVAL_WITHOUT_DATA_MS \
   "grpc.http2.min_ping_interval_without_data_ms"
+/** Maximum time to allow a request to be:
+    (1) received by the server, but
+    (2) not requested by a RequestCall (in the completion queue based API)
+    before the request is cancelled */
+#define GRPC_ARG_SERVER_MAX_UNREQUESTED_TIME_IN_SERVER_SECONDS \
+  "grpc.server_max_unrequested_time_in_server"
 /** Channel arg to override the http2 :scheme header */
 #define GRPC_ARG_HTTP2_SCHEME "grpc.http2_scheme"
 /** How many pings can the client send before needing to send a
@@ -384,6 +390,11 @@
  *  Defaults to 250ms. */
 #define GRPC_ARG_HAPPY_EYEBALLS_CONNECTION_ATTEMPT_DELAY_MS \
   "grpc.happy_eyeballs_connection_attempt_delay_ms"
+/** It accepts a MemoryAllocatorFactory as input and If specified, it forces
+ * the default event engine to use memory allocators created using the provided
+ * factory. */
+#define GRPC_ARG_EVENT_ENGINE_USE_MEMORY_ALLOCATOR_FACTORY \
+  "grpc.event_engine_use_memory_allocator_factory"
 /** \} */
 
 #endif /* GRPC_IMPL_CHANNEL_ARG_NAMES_H */

data/include/grpc/impl/slice_type.h

@@ -74,7 +74,7 @@ struct grpc_slice {
   } data;
 };
 
-#define GRPC_SLICE_BUFFER_INLINE_ELEMENTS 8
+#define GRPC_SLICE_BUFFER_INLINE_ELEMENTS 7
 
 /** Represents an expandable array of slices, to be interpreted as a
    single item. */

data/include/grpc/module.modulemap

@@ -13,6 +13,7 @@ header "byte_buffer.h"
   header "grpc_posix.h"
   header "grpc_security.h"
   header "grpc_security_constants.h"
+  header "impl/call.h"
   header "impl/channel_arg_names.h"
   header "impl/codegen/atm.h"
   header "impl/codegen/byte_buffer.h"

data/src/core/ext/filters/backend_metrics/backend_metric_filter.cc

@@ -26,7 +26,7 @@
 
 #include "absl/strings/string_view.h"
 #include "upb/base/string_view.h"
-#include "upb/upb.hpp"
+#include "upb/mem/arena.hpp"
 #include "xds/data/orca/v3/orca_load_report.upb.h"
 
 #include <grpc/impl/channel_arg_names.h>
@@ -37,6 +37,7 @@
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/slice/slice.h"
@@ -47,8 +48,15 @@ namespace grpc_core {
 
 TraceFlag grpc_backend_metric_filter_trace(false, "backend_metric_filter");
 
-absl::optional<std::string> BackendMetricFilter::MaybeSerializeBackendMetrics(
-    BackendMetricProvider* provider) const {
+const NoInterceptor BackendMetricFilter::Call::OnClientInitialMetadata;
+const NoInterceptor BackendMetricFilter::Call::OnServerInitialMetadata;
+const NoInterceptor BackendMetricFilter::Call::OnClientToServerMessage;
+const NoInterceptor BackendMetricFilter::Call::OnServerToClientMessage;
+const NoInterceptor BackendMetricFilter::Call::OnFinalize;
+
+namespace {
+absl::optional<std::string> MaybeSerializeBackendMetrics(
+    BackendMetricProvider* provider) {
   if (provider == nullptr) return absl::nullopt;
   BackendMetricData data = provider->GetBackendMetricData();
   upb::Arena arena;
@@ -107,17 +115,27 @@ absl::optional<std::string> BackendMetricFilter::MaybeSerializeBackendMetrics(
       xds_data_orca_v3_OrcaLoadReport_serialize(response, arena.ptr(), &len);
   return std::string(buf, len);
 }
+}  // namespace
+
+const grpc_channel_filter LegacyBackendMetricFilter::kFilter =
+    MakePromiseBasedFilter<LegacyBackendMetricFilter, FilterEndpoint::kServer>(
+        "backend_metric");
 
 const grpc_channel_filter BackendMetricFilter::kFilter =
     MakePromiseBasedFilter<BackendMetricFilter, FilterEndpoint::kServer>(
         "backend_metric");
 
+absl::StatusOr<LegacyBackendMetricFilter> LegacyBackendMetricFilter::Create(
+    const ChannelArgs&, ChannelFilter::Args) {
+  return LegacyBackendMetricFilter();
+}
+
 absl::StatusOr<BackendMetricFilter> BackendMetricFilter::Create(
     const ChannelArgs&, ChannelFilter::Args) {
   return BackendMetricFilter();
 }
 
-ArenaPromise<ServerMetadataHandle> BackendMetricFilter::MakeCallPromise(
+ArenaPromise<ServerMetadataHandle> LegacyBackendMetricFilter::MakeCallPromise(
     CallArgs call_args, NextPromiseFactory next_promise_factory) {
   return ArenaPromise<ServerMetadataHandle>(Map(
       next_promise_factory(std::move(call_args)),
@@ -148,10 +166,39 @@ ArenaPromise<ServerMetadataHandle> BackendMetricFilter::MakeCallPromise(
       }));
 }
 
+void BackendMetricFilter::Call::OnServerTrailingMetadata(ServerMetadata& md) {
+  auto* ctx = &GetContext<
+      grpc_call_context_element>()[GRPC_CONTEXT_BACKEND_METRIC_PROVIDER];
+  if (ctx == nullptr) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_backend_metric_filter_trace)) {
+      gpr_log(GPR_INFO, "[%p] No BackendMetricProvider.", this);
+    }
+    return;
+  }
+  absl::optional<std::string> serialized = MaybeSerializeBackendMetrics(
+      reinterpret_cast<BackendMetricProvider*>(ctx->value));
+  if (serialized.has_value() && !serialized->empty()) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_backend_metric_filter_trace)) {
+      gpr_log(GPR_INFO, "[%p] Backend metrics serialized. size: %" PRIuPTR,
+              this, serialized->size());
+    }
+    md.Set(EndpointLoadMetricsBinMetadata(),
+           Slice::FromCopiedString(std::move(*serialized)));
+  } else if (GRPC_TRACE_FLAG_ENABLED(grpc_backend_metric_filter_trace)) {
+    gpr_log(GPR_INFO, "[%p] No backend metrics.", this);
+  }
+}
+
 void RegisterBackendMetricFilter(CoreConfiguration::Builder* builder) {
-  builder->channel_init()
-      ->RegisterFilter(GRPC_SERVER_CHANNEL, &BackendMetricFilter::kFilter)
-      .IfHasChannelArg(GRPC_ARG_SERVER_CALL_METRIC_RECORDING);
+  if (IsV3BackendMetricFilterEnabled()) {
+    builder->channel_init()
+        ->RegisterFilter<BackendMetricFilter>(GRPC_SERVER_CHANNEL)
+        .IfHasChannelArg(GRPC_ARG_SERVER_CALL_METRIC_RECORDING);
+  } else {
+    builder->channel_init()
+        ->RegisterFilter<LegacyBackendMetricFilter>(GRPC_SERVER_CHANNEL)
+        .IfHasChannelArg(GRPC_ARG_SERVER_CALL_METRIC_RECORDING);
+  }
 }
 
 }  // namespace grpc_core

data/src/core/ext/filters/backend_metrics/backend_metric_filter.h

@@ -31,20 +31,34 @@
 
 namespace grpc_core {
 
-class BackendMetricFilter : public ChannelFilter {
+class LegacyBackendMetricFilter : public ChannelFilter {
  public:
   static const grpc_channel_filter kFilter;
 
-  static absl::StatusOr<BackendMetricFilter> Create(const ChannelArgs& args,
-                                                    ChannelFilter::Args);
+  static absl::StatusOr<LegacyBackendMetricFilter> Create(
+      const ChannelArgs& args, ChannelFilter::Args);
 
   // Construct a promise for one call.
   ArenaPromise<ServerMetadataHandle> MakeCallPromise(
       CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+};
+
+class BackendMetricFilter : public ImplementChannelFilter<BackendMetricFilter> {
+ public:
+  static const grpc_channel_filter kFilter;
+
+  static absl::StatusOr<BackendMetricFilter> Create(const ChannelArgs& args,
+                                                    ChannelFilter::Args);
 
- private:
-  absl::optional<std::string> MaybeSerializeBackendMetrics(
-      BackendMetricProvider* provider) const;
+  class Call {
+   public:
+    static const NoInterceptor OnClientInitialMetadata;
+    static const NoInterceptor OnServerInitialMetadata;
+    void OnServerTrailingMetadata(ServerMetadata& md);
+    static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnServerToClientMessage;
+    static const NoInterceptor OnFinalize;
+  };
 };
 
 }  // namespace grpc_core

data/src/core/ext/filters/channel_idle/channel_idle_filter.cc

@@ -56,6 +56,13 @@
 
 namespace grpc_core {
 
+const NoInterceptor ChannelIdleFilter::Call::OnClientInitialMetadata;
+const NoInterceptor ChannelIdleFilter::Call::OnServerInitialMetadata;
+const NoInterceptor ChannelIdleFilter::Call::OnServerTrailingMetadata;
+const NoInterceptor ChannelIdleFilter::Call::OnClientToServerMessage;
+const NoInterceptor ChannelIdleFilter::Call::OnServerToClientMessage;
+const NoInterceptor ChannelIdleFilter::Call::OnFinalize;
+
 namespace {
 
 // TODO(roth): This can go back to being a constant when the experiment
@@ -221,17 +228,6 @@ void MaxAgeFilter::PostInit() {
   }
 }
 
-// Construct a promise for one call.
-ArenaPromise<ServerMetadataHandle> ChannelIdleFilter::MakeCallPromise(
-    CallArgs call_args, NextPromiseFactory next_promise_factory) {
-  using Decrementer = std::unique_ptr<ChannelIdleFilter, CallCountDecreaser>;
-  IncreaseCallCount();
-  return ArenaPromise<ServerMetadataHandle>(
-      [decrementer = Decrementer(this),
-       next = next_promise_factory(std::move(call_args))]() mutable
-      -> Poll<ServerMetadataHandle> { return next(); });
-}
-
 bool ChannelIdleFilter::StartTransportOp(grpc_transport_op* op) {
   // Catch the disconnect_with_error transport op.
   if (!op->disconnect_with_error.ok()) Shutdown();
@@ -298,14 +294,15 @@ const grpc_channel_filter MaxAgeFilter::kFilter =
     MakePromiseBasedFilter<MaxAgeFilter, FilterEndpoint::kServer>("max_age");
 
 void RegisterChannelIdleFilters(CoreConfiguration::Builder* builder) {
+  if (!IsV3ChannelIdleFiltersEnabled()) return;
   builder->channel_init()
-      ->RegisterFilter(GRPC_CLIENT_CHANNEL, &ClientIdleFilter::kFilter)
+      ->RegisterFilter<ClientIdleFilter>(GRPC_CLIENT_CHANNEL)
       .ExcludeFromMinimalStack()
       .If([](const ChannelArgs& channel_args) {
         return GetClientIdleTimeout(channel_args) != Duration::Infinity();
       });
   builder->channel_init()
-      ->RegisterFilter(GRPC_SERVER_CHANNEL, &MaxAgeFilter::kFilter)
+      ->RegisterFilter<MaxAgeFilter>(GRPC_SERVER_CHANNEL)
       .ExcludeFromMinimalStack()
       .If([](const ChannelArgs& channel_args) {
         return MaxAgeFilter::Config::FromChannelArgs(channel_args).enable();

data/src/core/ext/filters/channel_idle/channel_idle_filter.h

@@ -40,7 +40,7 @@
 
 namespace grpc_core {
 
-class ChannelIdleFilter : public ChannelFilter {
+class ChannelIdleFilter : public ImplementChannelFilter<ChannelIdleFilter> {
  public:
   ~ChannelIdleFilter() override = default;
 
@@ -49,9 +49,23 @@ class ChannelIdleFilter : public ChannelFilter {
   ChannelIdleFilter(ChannelIdleFilter&&) = default;
   ChannelIdleFilter& operator=(ChannelIdleFilter&&) = default;
 
-  // Construct a promise for one call.
-  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
-      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+  class Call {
+   public:
+    explicit Call(ChannelIdleFilter* filter) : filter_(filter) {
+      filter_->IncreaseCallCount();
+    }
+    ~Call() { filter_->DecreaseCallCount(); }
+
+    static const NoInterceptor OnClientInitialMetadata;
+    static const NoInterceptor OnServerInitialMetadata;
+    static const NoInterceptor OnServerTrailingMetadata;
+    static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnServerToClientMessage;
+    static const NoInterceptor OnFinalize;
+
+   private:
+    ChannelIdleFilter* filter_;
+  };
 
   bool StartTransportOp(grpc_transport_op* op) override;
 
@@ -75,12 +89,6 @@ class ChannelIdleFilter : public ChannelFilter {
  private:
   void StartIdleTimer();
 
-  struct CallCountDecreaser {
-    void operator()(ChannelIdleFilter* filter) const {
-      filter->DecreaseCallCount();
-    }
-  };
-
   // The channel stack to which we take refs for pending callbacks.
   grpc_channel_stack* channel_stack_;
   Duration client_idle_timeout_;