grpc 1.48.0 → 1.50.0

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

@@ -22,22 +22,21 @@
 #include <limits.h>
 
 #include <algorithm>
-#include <cstring>
 #include <memory>
 #include <new>
-#include <type_traits>
 #include <utility>
 
 #include "absl/status/statusor.h"
+#include "absl/strings/cord.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 
-#include <grpc/grpc.h>
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/slice.h>
 #include <grpc/status.h>
-#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/filters/client_channel/health/health_check_client.h"
-#include "src/core/ext/filters/client_channel/proxy_mapper_registry.h"
 #include "src/core/ext/filters/client_channel/subchannel_pool_interface.h"
 #include "src/core/ext/filters/client_channel/subchannel_stream_client.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -51,23 +50,21 @@
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/event_engine/event_engine_factory.h"
+#include "src/core/lib/event_engine/default_event_engine.h"
 #include "src/core/lib/gpr/alloc.h"
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/handshaker/proxy_mapper_registry.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/pollset_set.h"
-#include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/surface/init_internally.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/error_utils.h"
 
-// Strong and weak refs.
-#define INTERNAL_REF_BITS 16
-#define STRONG_REF_MASK (~(gpr_atm)((1 << INTERNAL_REF_BITS) - 1))
-
 // Backoff parameters.
 #define GRPC_SUBCHANNEL_INITIAL_CONNECT_BACKOFF_SECONDS 1
 #define GRPC_SUBCHANNEL_RECONNECT_BACKOFF_MULTIPLIER 1.6
@@ -94,18 +91,17 @@ DebugOnlyTraceFlag grpc_trace_subchannel_refcount(false, "subchannel_refcount");
 //
 
 ConnectedSubchannel::ConnectedSubchannel(
-    grpc_channel_stack* channel_stack, const grpc_channel_args* args,
+    grpc_channel_stack* channel_stack, const ChannelArgs& args,
     RefCountedPtr<channelz::SubchannelNode> channelz_subchannel)
     : RefCounted<ConnectedSubchannel>(
           GRPC_TRACE_FLAG_ENABLED(grpc_trace_subchannel_refcount)
               ? "ConnectedSubchannel"
               : nullptr),
       channel_stack_(channel_stack),
-      args_(grpc_channel_args_copy(args)),
+      args_(args),
       channelz_subchannel_(std::move(channelz_subchannel)) {}
 
 ConnectedSubchannel::~ConnectedSubchannel() {
-  grpc_channel_args_destroy(args_);
   GRPC_CHANNEL_STACK_UNREF(channel_stack_, "connected_subchannel_dtor");
 }
 
@@ -177,7 +173,6 @@ SubchannelCall::SubchannelCall(Args args, grpc_error_handle* error)
 
 void SubchannelCall::StartTransportStreamOpBatch(
     grpc_transport_stream_op_batch* batch) {
-  GPR_TIMER_SCOPE("subchannel_call_process_op", 0);
   MaybeInterceptRecvTrailingMetadata(batch);
   grpc_call_stack* call_stack = SUBCHANNEL_CALL_TO_CALL_STACK(this);
   grpc_call_element* top_elem = grpc_call_stack_element(call_stack, 0);
@@ -216,7 +211,6 @@ void SubchannelCall::Unref(const DebugLocation& /*location*/,
 }
 
 void SubchannelCall::Destroy(void* arg, grpc_error_handle /*error*/) {
-  GPR_TIMER_SCOPE("subchannel_call_destroy", 0);
   SubchannelCall* self = static_cast<SubchannelCall*>(arg);
   // Keep some members before destroying the subchannel call.
   grpc_closure* after_call_stack_destroy = self->after_call_stack_destroy_;
@@ -585,54 +579,39 @@ Subchannel::ConnectivityStateWatcherInterface::PopConnectivityStateChange() {
 
 namespace {
 
-BackOff::Options ParseArgsForBackoffValues(const grpc_channel_args* args,
+BackOff::Options ParseArgsForBackoffValues(const ChannelArgs& args,
                                            Duration* min_connect_timeout) {
-  Duration initial_backoff =
-      Duration::Seconds(GRPC_SUBCHANNEL_INITIAL_CONNECT_BACKOFF_SECONDS);
+  const absl::optional<Duration> fixed_reconnect_backoff =
+      args.GetDurationFromIntMillis("grpc.testing.fixed_reconnect_backoff_ms");
+  if (fixed_reconnect_backoff.has_value()) {
+    const Duration backoff =
+        std::max(Duration::Milliseconds(100), *fixed_reconnect_backoff);
+    *min_connect_timeout = backoff;
+    return BackOff::Options()
+        .set_initial_backoff(backoff)
+        .set_multiplier(1.0)
+        .set_jitter(0.0)
+        .set_max_backoff(backoff);
+  }
+  const Duration initial_backoff = std::max(
+      Duration::Milliseconds(100),
+      args.GetDurationFromIntMillis(GRPC_ARG_INITIAL_RECONNECT_BACKOFF_MS)
+          .value_or(Duration::Seconds(
+              GRPC_SUBCHANNEL_INITIAL_CONNECT_BACKOFF_SECONDS)));
   *min_connect_timeout =
-      Duration::Seconds(GRPC_SUBCHANNEL_RECONNECT_MIN_TIMEOUT_SECONDS);
-  Duration max_backoff =
-      Duration::Seconds(GRPC_SUBCHANNEL_RECONNECT_MAX_BACKOFF_SECONDS);
-  bool fixed_reconnect_backoff = false;
-  if (args != nullptr) {
-    for (size_t i = 0; i < args->num_args; i++) {
-      if (0 == strcmp(args->args[i].key,
-                      "grpc.testing.fixed_reconnect_backoff_ms")) {
-        fixed_reconnect_backoff = true;
-        initial_backoff = *min_connect_timeout = max_backoff =
-            Duration::Milliseconds(grpc_channel_arg_get_integer(
-                &args->args[i],
-                {static_cast<int>(initial_backoff.millis()), 100, INT_MAX}));
-      } else if (0 ==
-                 strcmp(args->args[i].key, GRPC_ARG_MIN_RECONNECT_BACKOFF_MS)) {
-        fixed_reconnect_backoff = false;
-        *min_connect_timeout =
-            Duration::Milliseconds(grpc_channel_arg_get_integer(
-                &args->args[i],
-                {static_cast<int>(min_connect_timeout->millis()), 100,
-                 INT_MAX}));
-      } else if (0 ==
-                 strcmp(args->args[i].key, GRPC_ARG_MAX_RECONNECT_BACKOFF_MS)) {
-        fixed_reconnect_backoff = false;
-        max_backoff = Duration::Milliseconds(grpc_channel_arg_get_integer(
-            &args->args[i],
-            {static_cast<int>(max_backoff.millis()), 100, INT_MAX}));
-      } else if (0 == strcmp(args->args[i].key,
-                             GRPC_ARG_INITIAL_RECONNECT_BACKOFF_MS)) {
-        fixed_reconnect_backoff = false;
-        initial_backoff = Duration::Milliseconds(grpc_channel_arg_get_integer(
-            &args->args[i],
-            {static_cast<int>(initial_backoff.millis()), 100, INT_MAX}));
-      }
-    }
-  }
+      std::max(Duration::Milliseconds(100),
+               args.GetDurationFromIntMillis(GRPC_ARG_MIN_RECONNECT_BACKOFF_MS)
+                   .value_or(Duration::Seconds(
+                       GRPC_SUBCHANNEL_RECONNECT_MIN_TIMEOUT_SECONDS)));
+  const Duration max_backoff =
+      std::max(Duration::Milliseconds(100),
+               args.GetDurationFromIntMillis(GRPC_ARG_MAX_RECONNECT_BACKOFF_MS)
+                   .value_or(Duration::Seconds(
+                       GRPC_SUBCHANNEL_RECONNECT_MAX_BACKOFF_SECONDS)));
   return BackOff::Options()
       .set_initial_backoff(initial_backoff)
-      .set_multiplier(fixed_reconnect_backoff
-                          ? 1.0
-                          : GRPC_SUBCHANNEL_RECONNECT_BACKOFF_MULTIPLIER)
-      .set_jitter(fixed_reconnect_backoff ? 0.0
-                                          : GRPC_SUBCHANNEL_RECONNECT_JITTER)
+      .set_multiplier(GRPC_SUBCHANNEL_RECONNECT_BACKOFF_MULTIPLIER)
+      .set_jitter(GRPC_SUBCHANNEL_RECONNECT_JITTER)
       .set_max_backoff(max_backoff);
 }
 
@@ -640,14 +619,15 @@ BackOff::Options ParseArgsForBackoffValues(const grpc_channel_args* args,
 
 Subchannel::Subchannel(SubchannelKey key,
                        OrphanablePtr<SubchannelConnector> connector,
-                       const grpc_channel_args* args)
+                       const ChannelArgs& args)
     : DualRefCounted<Subchannel>(
           GRPC_TRACE_FLAG_ENABLED(grpc_trace_subchannel_refcount) ? "Subchannel"
                                                                   : nullptr),
       key_(std::move(key)),
+      args_(args),
       pollset_set_(grpc_pollset_set_create()),
       connector_(std::move(connector)),
-      backoff_(ParseArgsForBackoffValues(args, &min_connect_timeout_)) {
+      backoff_(ParseArgsForBackoffValues(args_, &min_connect_timeout_)) {
   // A grpc_init is added here to ensure that grpc_shutdown does not happen
   // until the subchannel is destroyed. Subchannels can persist longer than
   // channels because they maybe reused/shared among multiple channels. As a
@@ -656,35 +636,24 @@ Subchannel::Subchannel(SubchannelKey key,
   // before the last subchannel destruction, then there maybe race conditions
   // triggering segmentation faults. To prevent this issue, we call a grpc_init
   // here and a grpc_shutdown in the subchannel destructor.
-  grpc_init();
+  InitInternally();
   GRPC_STATS_INC_CLIENT_SUBCHANNELS_CREATED();
   GRPC_CLOSURE_INIT(&on_connecting_finished_, OnConnectingFinished, this,
                     grpc_schedule_on_exec_ctx);
   // Check proxy mapper to determine address to connect to and channel
   // args to use.
-  address_for_connect_ = key_.address();
-  grpc_resolved_address* new_address = nullptr;
-  grpc_channel_args* new_args = nullptr;
-  if (ProxyMapperRegistry::MapAddress(address_for_connect_, args, &new_address,
-                                      &new_args)) {
-    GPR_ASSERT(new_address != nullptr);
-    address_for_connect_ = *new_address;
-    gpr_free(new_address);
-  }
-  if (new_args != nullptr) {
-    args_ = new_args;
-  } else {
-    args_ = grpc_channel_args_copy(args);
-  }
+  address_for_connect_ = CoreConfiguration::Get()
+                             .proxy_mapper_registry()
+                             .MapAddress(key_.address(), &args_)
+                             .value_or(key_.address());
   // Initialize channelz.
-  const bool channelz_enabled = grpc_channel_args_find_bool(
-      args_, GRPC_ARG_ENABLE_CHANNELZ, GRPC_ENABLE_CHANNELZ_DEFAULT);
+  const bool channelz_enabled = args_.GetBool(GRPC_ARG_ENABLE_CHANNELZ)
+                                    .value_or(GRPC_ENABLE_CHANNELZ_DEFAULT);
   if (channelz_enabled) {
-    const size_t channel_tracer_max_memory =
-        static_cast<size_t>(grpc_channel_args_find_integer(
-            args_, GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE,
-            {GRPC_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE_DEFAULT, 0,
-             INT_MAX}));
+    const size_t channel_tracer_max_memory = Clamp(
+        args_.GetInt(GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE)
+            .value_or(GRPC_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE_DEFAULT),
+        0, INT_MAX);
     channelz_node_ = MakeRefCounted<channelz::SubchannelNode>(
         grpc_sockaddr_to_uri(&key_.address())
             .value_or("<unknown address type>"),
@@ -702,19 +671,17 @@ Subchannel::~Subchannel() {
         grpc_slice_from_static_string("Subchannel destroyed"));
     channelz_node_->UpdateConnectivityState(GRPC_CHANNEL_SHUTDOWN);
   }
-  grpc_channel_args_destroy(args_);
   connector_.reset();
   grpc_pollset_set_destroy(pollset_set_);
   // grpc_shutdown is called here because grpc_init is called in the ctor.
-  grpc_shutdown();
+  ShutdownInternally();
 }
 
 RefCountedPtr<Subchannel> Subchannel::Create(
     OrphanablePtr<SubchannelConnector> connector,
-    const grpc_resolved_address& address, const grpc_channel_args* args) {
+    const grpc_resolved_address& address, const ChannelArgs& args) {
   SubchannelKey key(address, args);
-  SubchannelPoolInterface* subchannel_pool =
-      SubchannelPoolInterface::GetSubchannelPoolFromChannelArgs(args);
+  auto* subchannel_pool = args.GetObject<SubchannelPoolInterface>();
   GPR_ASSERT(subchannel_pool != nullptr);
   RefCountedPtr<Subchannel> c = subchannel_pool->FindSubchannel(key);
   if (c != nullptr) {
@@ -740,13 +707,7 @@ void Subchannel::ThrottleKeepaliveTime(int new_keepalive_time) {
       gpr_log(GPR_INFO, "subchannel %p %s: throttling keepalive time to %d",
               this, key_.ToString().c_str(), new_keepalive_time);
     }
-    const grpc_arg arg_to_add = grpc_channel_arg_integer_create(
-        const_cast<char*>(GRPC_ARG_KEEPALIVE_TIME_MS), new_keepalive_time);
-    const char* arg_to_remove = GRPC_ARG_KEEPALIVE_TIME_MS;
-    grpc_channel_args* new_args = grpc_channel_args_copy_and_add_and_remove(
-        args_, &arg_to_remove, 1, &arg_to_add, 1);
-    grpc_channel_args_destroy(args_);
-    args_ = new_args;
+    args_ = args_.Set(GRPC_ARG_KEEPALIVE_TIME_MS, new_keepalive_time);
   }
 }
 
@@ -806,7 +767,7 @@ void Subchannel::ResetBackoff() {
       GetDefaultEventEngine()->Cancel(retry_timer_handle_)) {
     OnRetryTimerLocked();
   } else if (state_ == GRPC_CHANNEL_CONNECTING) {
-    next_attempt_time_ = ExecCtx::Get()->Now();
+    next_attempt_time_ = Timestamp::Now();
   }
 }
 
@@ -825,27 +786,20 @@ void Subchannel::Orphan() {
   health_watcher_map_.ShutdownLocked();
 }
 
-void Subchannel::AddDataProducer(DataProducerInterface* data_producer) {
+void Subchannel::GetOrAddDataProducer(
+    UniqueTypeName type,
+    std::function<void(DataProducerInterface**)> get_or_add) {
   MutexLock lock(&mu_);
-  auto& entry = data_producer_map_[data_producer->type()];
-  GPR_ASSERT(entry == nullptr);
-  entry = data_producer;
+  auto it = data_producer_map_.emplace(type, nullptr).first;
+  get_or_add(&it->second);
 }
 
 void Subchannel::RemoveDataProducer(DataProducerInterface* data_producer) {
   MutexLock lock(&mu_);
   auto it = data_producer_map_.find(data_producer->type());
-  GPR_ASSERT(it != data_producer_map_.end());
-  GPR_ASSERT(it->second == data_producer);
-  data_producer_map_.erase(it);
-}
-
-Subchannel::DataProducerInterface* Subchannel::GetDataProducer(
-    UniqueTypeName type) {
-  MutexLock lock(&mu_);
-  auto it = data_producer_map_.find(type);
-  if (it == data_producer_map_.end()) return nullptr;
-  return it->second;
+  if (it != data_producer_map_.end() && it->second == data_producer) {
+    data_producer_map_.erase(it);
+  }
 }
 
 namespace {
@@ -875,7 +829,21 @@ const char* SubchannelConnectivityStateChangeString(
 void Subchannel::SetConnectivityStateLocked(grpc_connectivity_state state,
                                             const absl::Status& status) {
   state_ = state;
-  status_ = status;
+  if (status.ok()) {
+    status_ = status;
+  } else {
+    // Augment status message to include IP address.
+    status_ = absl::Status(status.code(),
+                           absl::StrCat(grpc_sockaddr_to_uri(&key_.address())
+                                            .value_or("<unknown address type>"),
+                                        ": ", status.message()));
+    status.ForEachPayload(
+        [this](absl::string_view key, const absl::Cord& value)
+        // Want to use ABSL_EXCLUSIVE_LOCKS_REQUIRED(&mu_) here,
+        // but that won't work, because we can't pass the lock
+        // annotation through absl::Status::ForEachPayload().
+        ABSL_NO_THREAD_SAFETY_ANALYSIS { status_.SetPayload(key, value); });
+  }
   if (channelz_node_ != nullptr) {
     channelz_node_->UpdateConnectivityState(state);
     channelz_node_->AddTraceEvent(
@@ -884,9 +852,9 @@ void Subchannel::SetConnectivityStateLocked(grpc_connectivity_state state,
             SubchannelConnectivityStateChangeString(state)));
   }
   // Notify non-health watchers.
-  watcher_list_.NotifyLocked(state, status);
+  watcher_list_.NotifyLocked(state, status_);
   // Notify health watchers.
-  health_watcher_map_.NotifyLocked(state, status);
+  health_watcher_map_.NotifyLocked(state, status_);
 }
 
 void Subchannel::OnRetryTimer() {
@@ -903,7 +871,7 @@ void Subchannel::OnRetryTimerLocked() {
 
 void Subchannel::StartConnectingLocked() {
   // Set next attempt time.
-  const Timestamp min_deadline = min_connect_timeout_ + ExecCtx::Get()->Now();
+  const Timestamp min_deadline = min_connect_timeout_ + Timestamp::Now();
   next_attempt_time_ = backoff_.NextAttemptTime();
   // Report CONNECTING.
   SetConnectivityStateLocked(GRPC_CHANNEL_CONNECTING, absl::OkStatus());
@@ -919,13 +887,10 @@ void Subchannel::StartConnectingLocked() {
 
 void Subchannel::OnConnectingFinished(void* arg, grpc_error_handle error) {
   WeakRefCountedPtr<Subchannel> c(static_cast<Subchannel*>(arg));
-  const grpc_channel_args* delete_channel_args =
-      c->connecting_result_.channel_args;
   {
     MutexLock lock(&c->mu_);
     c->OnConnectingFinishedLocked(GRPC_ERROR_REF(error));
   }
-  grpc_channel_args_destroy(delete_channel_args);
   c.reset(DEBUG_LOCATION, "Connect");
 }
 
@@ -941,7 +906,7 @@ void Subchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
   // transition back to IDLE.
   if (connecting_result_.transport == nullptr || !PublishTransportLocked()) {
     const Duration time_until_next_attempt =
-        next_attempt_time_ - ExecCtx::Get()->Now();
+        next_attempt_time_ - Timestamp::Now();
     gpr_log(GPR_INFO,
             "subchannel %p %s: connect failed (%s), backing off for %" PRId64
             " ms",
@@ -972,7 +937,7 @@ void Subchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
 bool Subchannel::PublishTransportLocked() {
   // Construct channel stack.
   ChannelStackBuilderImpl builder("subchannel", GRPC_CLIENT_SUBCHANNEL);
-  builder.SetChannelArgs(ChannelArgs::FromC(connecting_result_.channel_args))
+  builder.SetChannelArgs(connecting_result_.channel_args)
       .SetTransport(connecting_result_.transport);
   if (!CoreConfiguration::Get().channel_init().CreateStack(&builder)) {
     return false;

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

@@ -22,6 +22,7 @@
 #include <stddef.h>
 
 #include <deque>
+#include <functional>
 #include <map>
 #include <string>
 
@@ -31,12 +32,12 @@
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/codegen/connectivity_state.h>
-#include <grpc/impl/codegen/grpc_types.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_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"
@@ -67,7 +68,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;
 
@@ -77,7 +78,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();
   }
@@ -86,7 +87,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_;
@@ -224,11 +225,11 @@ class Subchannel : public DualRefCounted<Subchannel> {
   // 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
@@ -238,7 +239,7 @@ class Subchannel : public DualRefCounted<Subchannel> {
 
   grpc_pollset_set* pollset_set() const { return pollset_set_; }
 
-  const grpc_channel_args* channel_args() const { return args_; }
+  const ChannelArgs& channel_args() const { return args_; }
 
   channelz::SubchannelNode* channelz_node();
 
@@ -278,12 +279,20 @@ class Subchannel : public DualRefCounted<Subchannel> {
   // We do not hold refs to the data producer; the implementation is
   // expected to register itself upon construction and remove itself
   // upon destruction.
-  void AddDataProducer(DataProducerInterface* data_producer)
+  //
+  // 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_);
-  DataProducerInterface* GetDataProducer(UniqueTypeName type)
-      ABSL_LOCKS_EXCLUDED(mu_);
 
  private:
   // A linked list of ConnectivityStateWatcherInterfaces that are monitoring
@@ -372,7 +381,7 @@ 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.

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

@@ -20,7 +20,7 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/filters/client_channel/subchannel.h"
-#include "src/core/ext/filters/client_channel/subchannel_interface.h"
+#include "src/core/lib/load_balancing/subchannel_interface.h"
 
 namespace grpc_core {
 

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

@@ -28,7 +28,6 @@
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/useful.h"
 
 // The subchannel pool to reuse subchannels.
 #define GRPC_ARG_SUBCHANNEL_POOL "grpc.internal.subchannel_pool"
@@ -40,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;
@@ -80,14 +48,7 @@ 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 {
@@ -95,42 +56,11 @@ std::string SubchannelKey::ToString() const {
   return absl::StrCat(
       "{address=",
       addr_uri.ok() ? addr_uri.value() : addr_uri.status().ToString(),
-      ", 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);
+      ", 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