grpc 1.42.0 → 1.46.3

data/src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_channel.h

@@ -1,44 +0,0 @@
-/*
- *
- * Copyright 2017 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_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_GRPCLB_GRPCLB_CHANNEL_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_GRPCLB_GRPCLB_CHANNEL_H
-
-#include <grpc/support/port_platform.h>
-
-#include <grpc/impl/codegen/grpc_types.h>
-
-#include "src/core/ext/filters/client_channel/server_address.h"
-
-namespace grpc_core {
-
-/// Makes any necessary modifications to \a args for use in the grpclb
-/// balancer channel.
-///
-/// Takes ownership of \a args.
-///
-/// Caller takes ownership of the returned args.
-grpc_channel_args* ModifyGrpclbBalancerChannelArgs(grpc_channel_args* args);
-
-grpc_channel* CreateGrpclbBalancerChannel(const char* target_uri,
-                                          const grpc_channel_args& args);
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_GRPCLB_GRPCLB_CHANNEL_H \
-        */

data/src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_channel_secure.cc

@@ -1,83 +0,0 @@
-/*
- *
- * Copyright 2017 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.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#include <string.h>
-
-#include "absl/container/inlined_vector.h"
-
-#include <grpc/grpc_security.h>
-#include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
-
-#include "src/core/ext/filters/client_channel/client_channel.h"
-#include "src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_balancer_addresses.h"
-#include "src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_channel.h"
-#include "src/core/ext/filters/client_channel/server_address.h"
-#include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/security/credentials/credentials.h"
-#include "src/core/lib/slice/slice_internal.h"
-
-namespace grpc_core {
-
-grpc_channel_args* ModifyGrpclbBalancerChannelArgs(grpc_channel_args* args) {
-  absl::InlinedVector<const char*, 1> args_to_remove;
-  absl::InlinedVector<grpc_arg, 1> args_to_add;
-  // Substitute the channel credentials with a version without call
-  // credentials: the load balancer is not necessarily trusted to handle
-  // bearer token credentials.
-  grpc_channel_credentials* channel_credentials =
-      grpc_channel_credentials_find_in_args(args);
-  RefCountedPtr<grpc_channel_credentials> creds_sans_call_creds;
-  if (channel_credentials != nullptr) {
-    creds_sans_call_creds =
-        channel_credentials->duplicate_without_call_credentials();
-    GPR_ASSERT(creds_sans_call_creds != nullptr);
-    args_to_remove.emplace_back(GRPC_ARG_CHANNEL_CREDENTIALS);
-    args_to_add.emplace_back(
-        grpc_channel_credentials_to_arg(creds_sans_call_creds.get()));
-  }
-  grpc_channel_args* result = grpc_channel_args_copy_and_add_and_remove(
-      args, args_to_remove.data(), args_to_remove.size(), args_to_add.data(),
-      args_to_add.size());
-  // Clean up.
-  grpc_channel_args_destroy(args);
-  return result;
-}
-
-grpc_channel* CreateGrpclbBalancerChannel(const char* target_uri,
-                                          const grpc_channel_args& args) {
-  grpc_channel_credentials* creds =
-      grpc_channel_credentials_find_in_args(&args);
-  if (creds == nullptr) {
-    // Build with security but parent channel is insecure.
-    return grpc_insecure_channel_create(target_uri, &args, nullptr);
-  }
-  const char* arg_to_remove = GRPC_ARG_CHANNEL_CREDENTIALS;
-  grpc_channel_args* new_args =
-      grpc_channel_args_copy_and_remove(&args, &arg_to_remove, 1);
-  grpc_channel* channel =
-      grpc_secure_channel_create(creds, target_uri, new_args, nullptr);
-  grpc_channel_args_destroy(new_args);
-  return channel;
-}
-
-}  // namespace grpc_core

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

@@ -1,195 +0,0 @@
-/*
- *
- * Copyright 2015 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.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/ext/filters/client_channel/resolver_registry.h"
-
-#include <string.h>
-
-#include "absl/container/inlined_vector.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-
-namespace grpc_core {
-
-namespace {
-
-class RegistryState {
- public:
-  RegistryState() : default_prefix_(gpr_strdup("dns:///")) {}
-
-  void SetDefaultPrefix(const char* default_resolver_prefix) {
-    GPR_ASSERT(default_resolver_prefix != nullptr);
-    GPR_ASSERT(*default_resolver_prefix != '\0');
-    default_prefix_.reset(gpr_strdup(default_resolver_prefix));
-  }
-
-  void RegisterResolverFactory(std::unique_ptr<ResolverFactory> factory) {
-    for (size_t i = 0; i < factories_.size(); ++i) {
-      GPR_ASSERT(strcmp(factories_[i]->scheme(), factory->scheme()) != 0);
-    }
-    factories_.push_back(std::move(factory));
-  }
-
-  ResolverFactory* LookupResolverFactory(absl::string_view scheme) const {
-    for (size_t i = 0; i < factories_.size(); ++i) {
-      if (scheme == factories_[i]->scheme()) {
-        return factories_[i].get();
-      }
-    }
-    return nullptr;
-  }
-
-  // Returns the factory for the scheme of \a target.  If \a target does
-  // not parse as a URI, prepends \a default_prefix_ and tries again.
-  // If URI parsing is successful (in either attempt), sets \a uri to
-  // point to the parsed URI.
-  // If \a default_prefix_ needs to be prepended, sets \a canonical_target
-  // to the canonical target string.
-  ResolverFactory* FindResolverFactory(absl::string_view target, URI* uri,
-                                       std::string* canonical_target) const {
-    GPR_ASSERT(uri != nullptr);
-    absl::StatusOr<URI> tmp_uri = URI::Parse(target);
-    ResolverFactory* factory =
-        tmp_uri.ok() ? LookupResolverFactory(tmp_uri->scheme()) : nullptr;
-    if (factory != nullptr) {
-      *uri = std::move(*tmp_uri);
-      return factory;
-    }
-    *canonical_target = absl::StrCat(default_prefix_.get(), target);
-    absl::StatusOr<URI> tmp_uri2 = URI::Parse(*canonical_target);
-    factory =
-        tmp_uri2.ok() ? LookupResolverFactory(tmp_uri2->scheme()) : nullptr;
-    if (factory != nullptr) {
-      *uri = std::move(*tmp_uri2);
-      return factory;
-    }
-    if (!tmp_uri.ok() || !tmp_uri2.ok()) {
-      gpr_log(GPR_ERROR, "%s",
-              absl::StrFormat("Error parsing URI(s). '%s':%s; '%s':%s", target,
-                              tmp_uri.status().ToString(), *canonical_target,
-                              tmp_uri2.status().ToString())
-                  .c_str());
-      return nullptr;
-    }
-    gpr_log(GPR_ERROR, "Don't know how to resolve '%s' or '%s'.",
-            std::string(target).c_str(), canonical_target->c_str());
-    return nullptr;
-  }
-
- private:
-  // We currently support 10 factories without doing additional
-  // allocation.  This number could be raised if there is a case where
-  // more factories are needed and the additional allocations are
-  // hurting performance (which is unlikely, since these allocations
-  // only occur at gRPC initialization time).
-  absl::InlinedVector<std::unique_ptr<ResolverFactory>, 10> factories_;
-  grpc_core::UniquePtr<char> default_prefix_;
-};
-
-static RegistryState* g_state = nullptr;
-
-}  // namespace
-
-//
-// ResolverRegistry::Builder
-//
-
-void ResolverRegistry::Builder::InitRegistry() {
-  if (g_state == nullptr) g_state = new RegistryState();
-}
-
-void ResolverRegistry::Builder::ShutdownRegistry() {
-  delete g_state;
-  g_state = nullptr;
-}
-
-void ResolverRegistry::Builder::SetDefaultPrefix(const char* default_prefix) {
-  InitRegistry();
-  g_state->SetDefaultPrefix(default_prefix);
-}
-
-void ResolverRegistry::Builder::RegisterResolverFactory(
-    std::unique_ptr<ResolverFactory> factory) {
-  InitRegistry();
-  g_state->RegisterResolverFactory(std::move(factory));
-}
-
-//
-// ResolverRegistry
-//
-
-ResolverFactory* ResolverRegistry::LookupResolverFactory(const char* scheme) {
-  GPR_ASSERT(g_state != nullptr);
-  return g_state->LookupResolverFactory(scheme);
-}
-
-bool ResolverRegistry::IsValidTarget(absl::string_view target) {
-  URI uri;
-  std::string canonical_target;
-  ResolverFactory* factory =
-      g_state->FindResolverFactory(target, &uri, &canonical_target);
-  return factory == nullptr ? false : factory->IsValidUri(uri);
-}
-
-OrphanablePtr<Resolver> ResolverRegistry::CreateResolver(
-    const char* target, const grpc_channel_args* args,
-    grpc_pollset_set* pollset_set,
-    std::shared_ptr<WorkSerializer> work_serializer,
-    std::unique_ptr<Resolver::ResultHandler> result_handler) {
-  GPR_ASSERT(g_state != nullptr);
-  ResolverArgs resolver_args;
-  ResolverFactory* factory = g_state->FindResolverFactory(
-      target, &resolver_args.uri, &resolver_args.uri_string);
-  if (factory == nullptr) return nullptr;
-  if (resolver_args.uri_string.empty()) resolver_args.uri_string = target;
-  resolver_args.args = args;
-  resolver_args.pollset_set = pollset_set;
-  resolver_args.work_serializer = std::move(work_serializer);
-  resolver_args.result_handler = std::move(result_handler);
-  return factory->CreateResolver(std::move(resolver_args));
-}
-
-std::string ResolverRegistry::GetDefaultAuthority(absl::string_view target) {
-  GPR_ASSERT(g_state != nullptr);
-  URI uri;
-  std::string canonical_target;
-  ResolverFactory* factory =
-      g_state->FindResolverFactory(target, &uri, &canonical_target);
-  std::string authority =
-      factory == nullptr ? "" : factory->GetDefaultAuthority(uri);
-  return authority;
-}
-
-grpc_core::UniquePtr<char> ResolverRegistry::AddDefaultPrefixIfNeeded(
-    const char* target) {
-  GPR_ASSERT(g_state != nullptr);
-  URI uri;
-  std::string canonical_target;
-  g_state->FindResolverFactory(target, &uri, &canonical_target);
-  return grpc_core::UniquePtr<char>(canonical_target.empty()
-                                        ? gpr_strdup(target)
-                                        : gpr_strdup(canonical_target.c_str()));
-}
-
-}  // namespace grpc_core

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

@@ -1,89 +0,0 @@
-/*
- *
- * Copyright 2015 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_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_REGISTRY_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_REGISTRY_H
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/ext/filters/client_channel/resolver_factory.h"
-#include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/iomgr/pollset_set.h"
-
-namespace grpc_core {
-
-class ResolverRegistry {
- public:
-  /// Methods used to create and populate the ResolverRegistry.
-  /// NOT THREAD SAFE -- to be used only during global gRPC
-  /// initialization and shutdown.
-  class Builder {
-   public:
-    /// Global initialization and shutdown hooks.
-    static void InitRegistry();
-    static void ShutdownRegistry();
-
-    /// Sets the default URI prefix to \a default_prefix.
-    /// Calls InitRegistry() if it has not already been called.
-    static void SetDefaultPrefix(const char* default_prefix);
-
-    /// Registers a resolver factory.  The factory will be used to create a
-    /// resolver for any URI whose scheme matches that of the factory.
-    /// Calls InitRegistry() if it has not already been called.
-    static void RegisterResolverFactory(
-        std::unique_ptr<ResolverFactory> factory);
-  };
-
-  /// Checks whether the user input \a target is valid to create a resolver.
-  static bool IsValidTarget(absl::string_view target);
-
-  /// Creates a resolver given \a target.
-  /// First tries to parse \a target as a URI. If this succeeds, tries
-  /// to locate a registered resolver factory based on the URI scheme.
-  /// If parsing fails or there is no factory for the URI's scheme,
-  /// prepends default_prefix to target and tries again.
-  /// If a resolver factory is found, uses it to instantiate a resolver and
-  /// returns it; otherwise, returns nullptr.
-  /// \a args, \a pollset_set, and \a work_serializer are passed to the
-  /// factory's \a CreateResolver() method. \a args are the channel args to be
-  /// included in resolver results. \a pollset_set is used to drive I/O in the
-  /// name resolution process. \a work_serializer is the work_serializer under
-  /// which all resolver calls will be run. \a result_handler is used to return
-  /// results from the resolver.
-  static OrphanablePtr<Resolver> CreateResolver(
-      const char* target, const grpc_channel_args* args,
-      grpc_pollset_set* pollset_set,
-      std::shared_ptr<WorkSerializer> work_serializer,
-      std::unique_ptr<Resolver::ResultHandler> result_handler);
-
-  /// Returns the default authority to pass from a client for \a target.
-  static std::string GetDefaultAuthority(absl::string_view target);
-
-  /// Returns \a target with the default prefix prepended, if needed.
-  static grpc_core::UniquePtr<char> AddDefaultPrefixIfNeeded(
-      const char* target);
-
-  /// Returns the resolver factory for \a scheme.
-  /// Caller does NOT own the return value.
-  static ResolverFactory* LookupResolverFactory(const char* scheme);
-};
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_REGISTRY_H */

data/src/core/ext/filters/client_idle/client_idle_filter.cc

@@ -1,264 +0,0 @@
-/*
- *
- * Copyright 2019 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.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#include <limits.h>
-
-#include <atomic>
-
-#include "src/core/ext/filters/client_idle/idle_filter_state.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/iomgr/timer.h"
-#include "src/core/lib/transport/http2_errors.h"
-
-// TODO(juanlishen): The idle filter is disabled in client channel by default
-// due to b/143502997. Try to fix the bug and enable the filter by default.
-#define DEFAULT_IDLE_TIMEOUT_MS INT_MAX
-// The user input idle timeout smaller than this would be capped to it.
-#define MIN_IDLE_TIMEOUT_MS (1 /*second*/ * 1000)
-
-namespace grpc_core {
-
-TraceFlag grpc_trace_client_idle_filter(false, "client_idle_filter");
-
-#define GRPC_IDLE_FILTER_LOG(format, ...)                               \
-  do {                                                                  \
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_client_idle_filter)) {       \
-      gpr_log(GPR_INFO, "(client idle filter) " format, ##__VA_ARGS__); \
-    }                                                                   \
-  } while (0)
-
-namespace {
-
-grpc_millis GetClientIdleTimeout(const grpc_channel_args* args) {
-  return std::max(
-      grpc_channel_arg_get_integer(
-          grpc_channel_args_find(args, GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS),
-          {DEFAULT_IDLE_TIMEOUT_MS, 0, INT_MAX}),
-      MIN_IDLE_TIMEOUT_MS);
-}
-
-class ChannelData {
- public:
-  static grpc_error_handle Init(grpc_channel_element* elem,
-                                grpc_channel_element_args* args);
-  static void Destroy(grpc_channel_element* elem);
-
-  static void StartTransportOp(grpc_channel_element* elem,
-                               grpc_transport_op* op);
-
-  void IncreaseCallCount();
-
-  void DecreaseCallCount();
-
- private:
-  ChannelData(grpc_channel_element* elem, grpc_channel_element_args* args,
-              grpc_error_handle* error);
-  ~ChannelData() = default;
-
-  static void IdleTimerCallback(void* arg, grpc_error_handle error);
-  static void IdleTransportOpCompleteCallback(void* arg,
-                                              grpc_error_handle error);
-
-  void StartIdleTimer();
-
-  void EnterIdle();
-
-  grpc_channel_element* elem_;
-  // The channel stack to which we take refs for pending callbacks.
-  grpc_channel_stack* channel_stack_;
-  // Timeout after the last RPC finishes on the client channel at which the
-  // channel goes back into IDLE state.
-  const grpc_millis client_idle_timeout_;
-
-  // Member data used to track the state of channel.
-  IdleFilterState idle_filter_state_{false};
-
-  // Idle timer and its callback closure.
-  grpc_timer idle_timer_;
-  grpc_closure idle_timer_callback_;
-
-  // The transport op telling the client channel to enter IDLE.
-  grpc_transport_op idle_transport_op_;
-  grpc_closure idle_transport_op_complete_callback_;
-};
-
-grpc_error_handle ChannelData::Init(grpc_channel_element* elem,
-                                    grpc_channel_element_args* args) {
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  new (elem->channel_data) ChannelData(elem, args, &error);
-  return error;
-}
-
-void ChannelData::Destroy(grpc_channel_element* elem) {
-  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
-  chand->~ChannelData();
-}
-
-void ChannelData::StartTransportOp(grpc_channel_element* elem,
-                                   grpc_transport_op* op) {
-  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
-  // Catch the disconnect_with_error transport op.
-  if (op->disconnect_with_error != GRPC_ERROR_NONE) {
-    // IncreaseCallCount() introduces a phony call and prevent the timer from
-    // being reset by other threads.
-    chand->IncreaseCallCount();
-    // If the timer has been set, cancel the timer.
-    // No synchronization issues here. grpc_timer_cancel() is valid as long as
-    // the timer has been init()ed before.
-    grpc_timer_cancel(&chand->idle_timer_);
-  }
-  // Pass the op to the next filter.
-  grpc_channel_next_op(elem, op);
-}
-
-void ChannelData::IncreaseCallCount() {
-  idle_filter_state_.IncreaseCallCount();
-}
-
-void ChannelData::DecreaseCallCount() {
-  if (idle_filter_state_.DecreaseCallCount()) {
-    // If there are no more calls in progress, start the idle timer.
-    StartIdleTimer();
-  }
-}
-
-ChannelData::ChannelData(grpc_channel_element* elem,
-                         grpc_channel_element_args* args,
-                         grpc_error_handle* /*error*/)
-    : elem_(elem),
-      channel_stack_(args->channel_stack),
-      client_idle_timeout_(GetClientIdleTimeout(args->channel_args)) {
-  // If the idle filter is explicitly disabled in channel args, this ctor should
-  // not get called.
-  GPR_ASSERT(client_idle_timeout_ != GRPC_MILLIS_INF_FUTURE);
-  GRPC_IDLE_FILTER_LOG("created with max_leisure_time = %" PRId64 " ms",
-                       client_idle_timeout_);
-  // Initialize the idle timer without setting it.
-  grpc_timer_init_unset(&idle_timer_);
-  // Initialize the idle timer callback closure.
-  GRPC_CLOSURE_INIT(&idle_timer_callback_, IdleTimerCallback, this,
-                    grpc_schedule_on_exec_ctx);
-  // Initialize the idle transport op complete callback.
-  GRPC_CLOSURE_INIT(&idle_transport_op_complete_callback_,
-                    IdleTransportOpCompleteCallback, this,
-                    grpc_schedule_on_exec_ctx);
-}
-
-void ChannelData::IdleTimerCallback(void* arg, grpc_error_handle error) {
-  GRPC_IDLE_FILTER_LOG("timer alarms");
-  ChannelData* chand = static_cast<ChannelData*>(arg);
-  if (error != GRPC_ERROR_NONE) {
-    GRPC_IDLE_FILTER_LOG("timer canceled");
-    GRPC_CHANNEL_STACK_UNREF(chand->channel_stack_, "max idle timer callback");
-    return;
-  }
-  if (chand->idle_filter_state_.CheckTimer()) {
-    chand->StartIdleTimer();
-  } else {
-    chand->EnterIdle();
-  }
-  GRPC_IDLE_FILTER_LOG("timer finishes");
-  GRPC_CHANNEL_STACK_UNREF(chand->channel_stack_, "max idle timer callback");
-}
-
-void ChannelData::IdleTransportOpCompleteCallback(void* arg,
-                                                  grpc_error_handle /*error*/) {
-  ChannelData* chand = static_cast<ChannelData*>(arg);
-  GRPC_CHANNEL_STACK_UNREF(chand->channel_stack_, "idle transport op");
-}
-
-void ChannelData::StartIdleTimer() {
-  GRPC_IDLE_FILTER_LOG("timer has started");
-  // Hold a ref to the channel stack for the timer callback.
-  GRPC_CHANNEL_STACK_REF(channel_stack_, "max idle timer callback");
-  grpc_timer_init(&idle_timer_, ExecCtx::Get()->Now() + client_idle_timeout_,
-                  &idle_timer_callback_);
-}
-
-void ChannelData::EnterIdle() {
-  GRPC_IDLE_FILTER_LOG("the channel will enter IDLE");
-  // Hold a ref to the channel stack for the transport op.
-  GRPC_CHANNEL_STACK_REF(channel_stack_, "idle transport op");
-  // Initialize the transport op.
-  idle_transport_op_ = {};
-  idle_transport_op_.disconnect_with_error = grpc_error_set_int(
-      GRPC_ERROR_CREATE_FROM_STATIC_STRING("enter idle"),
-      GRPC_ERROR_INT_CHANNEL_CONNECTIVITY_STATE, GRPC_CHANNEL_IDLE);
-  idle_transport_op_.on_consumed = &idle_transport_op_complete_callback_;
-  // Pass the transport op down to the channel stack.
-  grpc_channel_next_op(elem_, &idle_transport_op_);
-}
-
-class CallData {
- public:
-  static grpc_error_handle Init(grpc_call_element* elem,
-                                const grpc_call_element_args* args);
-  static void Destroy(grpc_call_element* elem,
-                      const grpc_call_final_info* final_info,
-                      grpc_closure* then_schedule_closure);
-};
-
-grpc_error_handle CallData::Init(grpc_call_element* elem,
-                                 const grpc_call_element_args* /*args*/) {
-  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
-  chand->IncreaseCallCount();
-  return GRPC_ERROR_NONE;
-}
-
-void CallData::Destroy(grpc_call_element* elem,
-                       const grpc_call_final_info* /*final_info*/,
-                       grpc_closure* /*ignored*/) {
-  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
-  chand->DecreaseCallCount();
-}
-
-const grpc_channel_filter grpc_client_idle_filter = {
-    grpc_call_next_op,
-    ChannelData::StartTransportOp,
-    sizeof(CallData),
-    CallData::Init,
-    grpc_call_stack_ignore_set_pollset_or_pollset_set,
-    CallData::Destroy,
-    sizeof(ChannelData),
-    ChannelData::Init,
-    ChannelData::Destroy,
-    grpc_channel_next_get_info,
-    "client_idle"};
-
-}  // namespace
-
-void RegisterClientIdleFilter(CoreConfiguration::Builder* builder) {
-  builder->channel_init()->RegisterStage(
-      GRPC_CLIENT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      [](grpc_channel_stack_builder* builder) {
-        const grpc_channel_args* channel_args =
-            grpc_channel_stack_builder_get_channel_arguments(builder);
-        if (!grpc_channel_args_want_minimal_stack(channel_args) &&
-            GetClientIdleTimeout(channel_args) != INT_MAX) {
-          return grpc_channel_stack_builder_prepend_filter(
-              builder, &grpc_client_idle_filter, nullptr, nullptr);
-        } else {
-          return true;
-        }
-      });
-}
-}  // namespace grpc_core