grpc 1.45.0 → 1.53.0

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

@@ -14,27 +14,53 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_H
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_H
 
 #include <grpc/support/port_platform.h>
 
-#include <deque>
+#include <stddef.h>
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <string>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/status/status.h"
+#include "absl/types/optional.h"
+
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/impl/connectivity_state.h>
 
 #include "src/core/ext/filters/client_channel/client_channel_channelz.h"
 #include "src/core/ext/filters/client_channel/connector.h"
 #include "src/core/ext/filters/client_channel/subchannel_pool_interface.h"
 #include "src/core/lib/backoff/backoff.h"
-#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_fwd.h"
+#include "src/core/lib/channel/context.h"
 #include "src/core/lib/gpr/time_precise.h"
+#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/dual_ref_counted.h"
+#include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/unique_type_name.h"
+#include "src/core/lib/gprpp/work_serializer.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/iomgr/resolved_address.h"
 #include "src/core/lib/resource_quota/arena.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/connectivity_state.h"
+#include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 
@@ -43,7 +69,7 @@ class SubchannelCall;
 class ConnectedSubchannel : public RefCounted<ConnectedSubchannel> {
  public:
   ConnectedSubchannel(
-      grpc_channel_stack* channel_stack, const grpc_channel_args* args,
+      grpc_channel_stack* channel_stack, const ChannelArgs& args,
       RefCountedPtr<channelz::SubchannelNode> channelz_subchannel);
   ~ConnectedSubchannel() override;
 
@@ -53,7 +79,7 @@ class ConnectedSubchannel : public RefCounted<ConnectedSubchannel> {
   void Ping(grpc_closure* on_initiate, grpc_closure* on_ack);
 
   grpc_channel_stack* channel_stack() const { return channel_stack_; }
-  const grpc_channel_args* args() const { return args_; }
+  const ChannelArgs& args() const { return args_; }
   channelz::SubchannelNode* channelz_subchannel() const {
     return channelz_subchannel_.get();
   }
@@ -62,7 +88,7 @@ class ConnectedSubchannel : public RefCounted<ConnectedSubchannel> {
 
  private:
   grpc_channel_stack* channel_stack_;
-  grpc_channel_args* args_;
+  ChannelArgs args_;
   // ref counted pointer to the channelz node in this connected subchannel's
   // owning subchannel.
   RefCountedPtr<channelz::SubchannelNode> channelz_subchannel_;
@@ -141,56 +167,42 @@ class SubchannelCall {
 // (SubchannelWrapper) that "converts" between the two.
 class Subchannel : public DualRefCounted<Subchannel> {
  public:
+  // TODO(roth): Once we remove pollset_set, consider whether this can
+  // just use the normal AsyncConnectivityStateWatcherInterface API.
   class ConnectivityStateWatcherInterface
       : public RefCounted<ConnectivityStateWatcherInterface> {
    public:
-    struct ConnectivityStateChange {
-      grpc_connectivity_state state;
-      absl::Status status;
-    };
-
-    ~ConnectivityStateWatcherInterface() override = default;
-
-    // Will be invoked whenever the subchannel's connectivity state
-    // changes.  There will be only one invocation of this method on a
-    // given watcher instance at any given time.
-    // Implementations should call PopConnectivityStateChange to get the next
-    // connectivity state change.
-    virtual void OnConnectivityStateChange() = 0;
+    // Invoked whenever the subchannel's connectivity state changes.
+    // There will be only one invocation of this method on a given watcher
+    // instance at any given time.
+    virtual void OnConnectivityStateChange(grpc_connectivity_state state,
+                                           const absl::Status& status) = 0;
 
     virtual grpc_pollset_set* interested_parties() = 0;
+  };
 
-    // Enqueues connectivity state change notifications.
-    // When the state changes to READY, connected_subchannel will
-    // contain a ref to the connected subchannel.  When it changes from
-    // READY to some other state, the implementation must release its
-    // ref to the connected subchannel.
-    // TODO(yashkt): This is currently needed to send the state updates in the
-    // right order when asynchronously notifying. This will no longer be
-    // necessary when we have access to EventManager.
-    void PushConnectivityStateChange(ConnectivityStateChange state_change);
-
-    // Dequeues connectivity state change notifications.
-    ConnectivityStateChange PopConnectivityStateChange();
-
-   private:
-    Mutex mu_;  // protects the queue
-    // Keeps track of the updates that the watcher instance must be notified of.
-    // TODO(yashkt): This is currently needed to send the state updates in the
-    // right order when asynchronously notifying. This will no longer be
-    // necessary when we have access to EventManager.
-    std::deque<ConnectivityStateChange> connectivity_state_queue_
-        ABSL_GUARDED_BY(&mu_);
+  // A base class for producers of subchannel-specific data.
+  // Implementations will typically add their own methods as needed.
+  class DataProducerInterface : public DualRefCounted<DataProducerInterface> {
+   public:
+    // A unique identifier for this implementation.
+    // Only one producer may be registered under a given type name on a
+    // given subchannel at any given time.
+    // Note that we use the pointer address instead of the string
+    // contents for uniqueness; all instances for a given implementation
+    // are expected to return the same string *instance*, not just the
+    // same string contents.
+    virtual UniqueTypeName type() const = 0;
   };
 
   // Creates a subchannel.
   static RefCountedPtr<Subchannel> Create(
       OrphanablePtr<SubchannelConnector> connector,
-      const grpc_resolved_address& address, const grpc_channel_args* args);
+      const grpc_resolved_address& address, const ChannelArgs& args);
 
   // The ctor and dtor are not intended to use directly.
   Subchannel(SubchannelKey key, OrphanablePtr<SubchannelConnector> connector,
-             const grpc_channel_args* args);
+             const ChannelArgs& args);
   ~Subchannel() override;
 
   // Throttles keepalive time to \a new_keepalive_time iff \a new_keepalive_time
@@ -198,28 +210,17 @@ class Subchannel : public DualRefCounted<Subchannel> {
   // will have an affect when the subchannel creates a new ConnectedSubchannel.
   void ThrottleKeepaliveTime(int new_keepalive_time) ABSL_LOCKS_EXCLUDED(mu_);
 
-  const grpc_channel_args* channel_args() const { return args_; }
+  grpc_pollset_set* pollset_set() const { return pollset_set_; }
 
   channelz::SubchannelNode* channelz_node();
 
-  // Returns the current connectivity state of the subchannel.
-  // If health_check_service_name is non-null, the returned connectivity
-  // state will be based on the state reported by the backend for that
-  // service name.
-  grpc_connectivity_state CheckConnectivityState(
-      const absl::optional<std::string>& health_check_service_name)
-      ABSL_LOCKS_EXCLUDED(mu_);
-
   // Starts watching the subchannel's connectivity state.
-  // The first callback to the watcher will be delivered when the
-  // subchannel's connectivity state becomes a value other than
-  // initial_state, which may happen immediately.
+  // The first callback to the watcher will be delivered ~immediately.
   // Subsequent callbacks will be delivered as the subchannel's state
   // changes.
   // The watcher will be destroyed either when the subchannel is
   // destroyed or when CancelConnectivityStateWatch() is called.
   void WatchConnectivityState(
-      grpc_connectivity_state initial_state,
       const absl::optional<std::string>& health_check_service_name,
       RefCountedPtr<ConnectivityStateWatcherInterface> watcher)
       ABSL_LOCKS_EXCLUDED(mu_);
@@ -237,7 +238,7 @@ class Subchannel : public DualRefCounted<Subchannel> {
   }
 
   // Attempt to connect to the backend.  Has no effect if already connected.
-  void AttemptToConnect() ABSL_LOCKS_EXCLUDED(mu_);
+  void RequestConnection() ABSL_LOCKS_EXCLUDED(mu_);
 
   // Resets the connection backoff of the subchannel.
   void ResetBackoff() ABSL_LOCKS_EXCLUDED(mu_);
@@ -245,11 +246,33 @@ class Subchannel : public DualRefCounted<Subchannel> {
   // Tears down any existing connection, and arranges for destruction
   void Orphan() override ABSL_LOCKS_EXCLUDED(mu_);
 
+  // Access to data producer map.
+  // We do not hold refs to the data producer; the implementation is
+  // expected to register itself upon construction and remove itself
+  // upon destruction.
+  //
+  // Looks up the current data producer for type and invokes get_or_add()
+  // with a pointer to that producer in the map.  The get_or_add() function
+  // can modify the pointed-to value to update the map.  This provides a
+  // way to either re-use an existing producer or register a new one in
+  // a non-racy way.
+  void GetOrAddDataProducer(
+      UniqueTypeName type,
+      std::function<void(DataProducerInterface**)> get_or_add)
+      ABSL_LOCKS_EXCLUDED(mu_);
+  // Removes the data producer from the map, if the current producer for
+  // this type is the specified producer.
+  void RemoveDataProducer(DataProducerInterface* data_producer)
+      ABSL_LOCKS_EXCLUDED(mu_);
+
  private:
   // A linked list of ConnectivityStateWatcherInterfaces that are monitoring
   // the subchannel's state.
   class ConnectivityStateWatcherList {
    public:
+    explicit ConnectivityStateWatcherList(Subchannel* subchannel)
+        : subchannel_(subchannel) {}
+
     ~ConnectivityStateWatcherList() { Clear(); }
 
     void AddWatcherLocked(
@@ -265,6 +288,7 @@ class Subchannel : public DualRefCounted<Subchannel> {
     bool empty() const { return watchers_.empty(); }
 
    private:
+    Subchannel* subchannel_;
     // TODO(roth): Once we can use C++-14 heterogeneous lookups, this can
     // be a set instead of a map.
     std::map<ConnectivityStateWatcherInterface*,
@@ -285,7 +309,6 @@ class Subchannel : public DualRefCounted<Subchannel> {
    public:
     void AddWatcherLocked(
         WeakRefCountedPtr<Subchannel> subchannel,
-        grpc_connectivity_state initial_state,
         const std::string& health_check_service_name,
         RefCountedPtr<ConnectivityStateWatcherInterface> watcher);
     void RemoveWatcherLocked(const std::string& health_check_service_name,
@@ -309,20 +332,19 @@ class Subchannel : public DualRefCounted<Subchannel> {
 
   class ConnectedSubchannelStateWatcher;
 
-  class AsyncWatcherNotifierLocked;
-
   // Sets the subchannel's connectivity state to \a state.
   void SetConnectivityStateLocked(grpc_connectivity_state state,
                                   const absl::Status& status)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
   // Methods for connection.
-  void MaybeStartConnectingLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-  static void OnRetryAlarm(void* arg, grpc_error_handle error)
-      ABSL_LOCKS_EXCLUDED(mu_);
-  void ContinueConnectingLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  void OnRetryTimer() ABSL_LOCKS_EXCLUDED(mu_);
+  void OnRetryTimerLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  void StartConnectingLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
   static void OnConnectingFinished(void* arg, grpc_error_handle error)
       ABSL_LOCKS_EXCLUDED(mu_);
+  void OnConnectingFinishedLocked(grpc_error_handle error)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
   bool PublishTransportLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
   // The subchannel pool this subchannel is in.
@@ -333,11 +355,13 @@ class Subchannel : public DualRefCounted<Subchannel> {
   // key_ if overridden by proxy mapper.
   grpc_resolved_address address_for_connect_;
   // Channel args.
-  grpc_channel_args* args_;
+  ChannelArgs args_;
   // pollset_set tracking who's interested in a connection being setup.
   grpc_pollset_set* pollset_set_;
   // Channelz tracking.
   RefCountedPtr<channelz::SubchannelNode> channelz_node_;
+  // Minimum connection timeout.
+  Duration min_connect_timeout_;
 
   // Connection state.
   OrphanablePtr<SubchannelConnector> connector_;
@@ -347,36 +371,42 @@ class Subchannel : public DualRefCounted<Subchannel> {
   // Protects the other members.
   Mutex mu_;
 
-  // Active connection, or null.
-  RefCountedPtr<ConnectedSubchannel> connected_subchannel_ ABSL_GUARDED_BY(mu_);
-  bool connecting_ ABSL_GUARDED_BY(mu_) = false;
-  bool disconnected_ ABSL_GUARDED_BY(mu_) = false;
+  bool shutdown_ ABSL_GUARDED_BY(mu_) = false;
 
   // Connectivity state tracking.
+  // Note that the connectivity state implies the state of the
+  // Subchannel object:
+  // - IDLE: no retry timer pending, can start a connection attempt at any time
+  // - CONNECTING: connection attempt in progress
+  // - READY: connection attempt succeeded, connected_subchannel_ created
+  // - TRANSIENT_FAILURE: connection attempt failed, retry timer pending
   grpc_connectivity_state state_ ABSL_GUARDED_BY(mu_) = GRPC_CHANNEL_IDLE;
   absl::Status status_ ABSL_GUARDED_BY(mu_);
   // The list of watchers without a health check service name.
   ConnectivityStateWatcherList watcher_list_ ABSL_GUARDED_BY(mu_);
   // The map of watchers with health check service names.
   HealthWatcherMap health_watcher_map_ ABSL_GUARDED_BY(mu_);
+  // Used for sending connectivity state notifications.
+  WorkSerializer work_serializer_;
+
+  // Active connection, or null.
+  RefCountedPtr<ConnectedSubchannel> connected_subchannel_ ABSL_GUARDED_BY(mu_);
 
-  // Minimum connect timeout - must be located before backoff_.
-  Duration min_connect_timeout_ ABSL_GUARDED_BY(mu_);
   // Backoff state.
   BackOff backoff_ ABSL_GUARDED_BY(mu_);
-  Timestamp next_attempt_deadline_ ABSL_GUARDED_BY(mu_);
-  bool backoff_begun_ ABSL_GUARDED_BY(mu_) = false;
-
-  // Retry alarm.
-  grpc_timer retry_alarm_ ABSL_GUARDED_BY(mu_);
-  grpc_closure on_retry_alarm_ ABSL_GUARDED_BY(mu_);
-  bool have_retry_alarm_ ABSL_GUARDED_BY(mu_) = false;
-  // reset_backoff() was called while alarm was pending.
-  bool retry_immediately_ ABSL_GUARDED_BY(mu_) = false;
+  Timestamp next_attempt_time_ ABSL_GUARDED_BY(mu_);
+  grpc_event_engine::experimental::EventEngine::TaskHandle retry_timer_handle_
+      ABSL_GUARDED_BY(mu_);
+
   // Keepalive time period (-1 for unset)
   int keepalive_time_ ABSL_GUARDED_BY(mu_) = -1;
+
+  // Data producer map.
+  std::map<UniqueTypeName, DataProducerInterface*> data_producer_map_
+      ABSL_GUARDED_BY(mu_);
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine_;
 };
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_H
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_H

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

@@ -0,0 +1,38 @@
+//
+// Copyright 2022 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_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_INTERFACE_INTERNAL_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_INTERFACE_INTERNAL_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/client_channel/subchannel.h"
+#include "src/core/lib/load_balancing/subchannel_interface.h"
+
+namespace grpc_core {
+
+// Internal interface for watching data of a particular type for this
+// subchannel.
+class InternalSubchannelDataWatcherInterface
+    : public SubchannelInterface::DataWatcherInterface {
+ public:
+  // Tells the watcher which subchannel to register itself with.
+  virtual void SetSubchannel(Subchannel* subchannel) = 0;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_INTERFACE_INTERNAL_H

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

@@ -20,8 +20,14 @@
 
 #include "src/core/ext/filters/client_channel/subchannel_pool_interface.h"
 
+#include <string.h>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+
 #include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/channel/channel_args.h"
 
 // The subchannel pool to reuse subchannels.
 #define GRPC_ARG_SUBCHANNEL_POOL "grpc.internal.subchannel_pool"
@@ -33,39 +39,8 @@ namespace grpc_core {
 TraceFlag grpc_subchannel_pool_trace(false, "subchannel_pool");
 
 SubchannelKey::SubchannelKey(const grpc_resolved_address& address,
-                             const grpc_channel_args* args) {
-  Init(address, args, grpc_channel_args_normalize);
-}
-
-SubchannelKey::~SubchannelKey() {
-  grpc_channel_args_destroy(const_cast<grpc_channel_args*>(args_));
-}
-
-SubchannelKey::SubchannelKey(const SubchannelKey& other) {
-  Init(other.address_, other.args_, grpc_channel_args_copy);
-}
-
-SubchannelKey& SubchannelKey::operator=(const SubchannelKey& other) {
-  if (&other == this) {
-    return *this;
-  }
-  grpc_channel_args_destroy(const_cast<grpc_channel_args*>(args_));
-  Init(other.address_, other.args_, grpc_channel_args_copy);
-  return *this;
-}
-
-SubchannelKey::SubchannelKey(SubchannelKey&& other) noexcept {
-  address_ = other.address_;
-  args_ = other.args_;
-  other.args_ = nullptr;
-}
-
-SubchannelKey& SubchannelKey::operator=(SubchannelKey&& other) noexcept {
-  address_ = other.address_;
-  args_ = other.args_;
-  other.args_ = nullptr;
-  return *this;
-}
+                             const ChannelArgs& args)
+    : address_(address), args_(args) {}
 
 bool SubchannelKey::operator<(const SubchannelKey& other) const {
   if (address_.len < other.address_.len) return true;
@@ -73,54 +48,19 @@ bool SubchannelKey::operator<(const SubchannelKey& other) const {
   int r = memcmp(address_.addr, other.address_.addr, address_.len);
   if (r < 0) return true;
   if (r > 0) return false;
-  return grpc_channel_args_compare(args_, other.args_) < 0;
-}
-
-void SubchannelKey::Init(
-    const grpc_resolved_address& address, const grpc_channel_args* args,
-    grpc_channel_args* (*copy_channel_args)(const grpc_channel_args* args)) {
-  address_ = address;
-  args_ = copy_channel_args(args);
+  return args_ < other.args();
 }
 
 std::string SubchannelKey::ToString() const {
-  return absl::StrCat("{address=", grpc_sockaddr_to_uri(&address_),
-                      ", args=", grpc_channel_args_string(args_), "}");
-}
-
-namespace {
-
-void* arg_copy(void* p) {
-  auto* subchannel_pool = static_cast<SubchannelPoolInterface*>(p);
-  subchannel_pool->Ref().release();
-  return p;
-}
-
-void arg_destroy(void* p) {
-  auto* subchannel_pool = static_cast<SubchannelPoolInterface*>(p);
-  subchannel_pool->Unref();
-}
-
-int arg_cmp(void* a, void* b) { return QsortCompare(a, b); }
-
-const grpc_arg_pointer_vtable subchannel_pool_arg_vtable = {
-    arg_copy, arg_destroy, arg_cmp};
-
-}  // namespace
-
-grpc_arg SubchannelPoolInterface::CreateChannelArg(
-    SubchannelPoolInterface* subchannel_pool) {
-  return grpc_channel_arg_pointer_create(
-      const_cast<char*>(GRPC_ARG_SUBCHANNEL_POOL), subchannel_pool,
-      &subchannel_pool_arg_vtable);
+  auto addr_uri = grpc_sockaddr_to_uri(&address_);
+  return absl::StrCat(
+      "{address=",
+      addr_uri.ok() ? addr_uri.value() : addr_uri.status().ToString(),
+      ", args=", args_.ToString(), "}");
 }
 
-SubchannelPoolInterface*
-SubchannelPoolInterface::GetSubchannelPoolFromChannelArgs(
-    const grpc_channel_args* args) {
-  const grpc_arg* arg = grpc_channel_args_find(args, GRPC_ARG_SUBCHANNEL_POOL);
-  if (arg == nullptr || arg->type != GRPC_ARG_POINTER) return nullptr;
-  return static_cast<SubchannelPoolInterface*>(arg->value.pointer.p);
+absl::string_view SubchannelPoolInterface::ChannelArgName() {
+  return GRPC_ARG_SUBCHANNEL_POOL;
 }
 
 }  // namespace grpc_core

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

@@ -1,31 +1,36 @@
-/*
- *
- * Copyright 2018 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_SUBCHANNEL_POOL_INTERFACE_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_POOL_INTERFACE_H
+//
+//
+// Copyright 2018 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_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_POOL_INTERFACE_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_POOL_INTERFACE_H
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/avl/avl.h"
+#include <string>
+
+#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/iomgr/resolve_address.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 
 namespace grpc_core {
 
@@ -36,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.
@@ -78,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.
@@ -92,15 +93,8 @@ 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
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_POOL_INTERFACE_H */
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_POOL_INTERFACE_H