grpc 1.25.0 → 1.26.0.pre1

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

@@ -47,7 +47,8 @@ class ResolverRegistry {
     /// 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(UniquePtr<ResolverFactory> factory);
+    static void RegisterResolverFactory(
+        std::unique_ptr<ResolverFactory> factory);
   };
 
   /// Checks whether the user input \a target is valid to create a resolver.
@@ -69,13 +70,14 @@ class ResolverRegistry {
   static OrphanablePtr<Resolver> CreateResolver(
       const char* target, const grpc_channel_args* args,
       grpc_pollset_set* pollset_set, Combiner* combiner,
-      UniquePtr<Resolver::ResultHandler> result_handler);
+      std::unique_ptr<Resolver::ResultHandler> result_handler);
 
   /// Returns the default authority to pass from a client for \a target.
-  static UniquePtr<char> GetDefaultAuthority(const char* target);
+  static grpc_core::UniquePtr<char> GetDefaultAuthority(const char* target);
 
   /// Returns \a target with the default prefix prepended, if needed.
-  static UniquePtr<char> AddDefaultPrefixIfNeeded(const char* target);
+  static grpc_core::UniquePtr<char> AddDefaultPrefixIfNeeded(
+      const char* target);
 
   /// Returns the resolver factory for \a scheme.
   /// Caller does NOT own the return value.

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

@@ -66,7 +66,7 @@ bool ParseDuration(grpc_json* field, grpc_millis* duration) {
   if (field->type != GRPC_JSON_STRING) return false;
   size_t len = strlen(field->value);
   if (field->value[len - 1] != 's') return false;
-  UniquePtr<char> buf(gpr_strdup(field->value));
+  grpc_core::UniquePtr<char> buf(gpr_strdup(field->value));
   *(buf.get() + len - 1) = '\0';  // Remove trailing 's'.
   char* decimal_point = strchr(buf.get(), '.');
   int nanos = 0;
@@ -91,7 +91,7 @@ bool ParseDuration(grpc_json* field, grpc_millis* duration) {
   return true;
 }
 
-UniquePtr<ClientChannelMethodParsedConfig::RetryPolicy> ParseRetryPolicy(
+std::unique_ptr<ClientChannelMethodParsedConfig::RetryPolicy> ParseRetryPolicy(
     grpc_json* field, grpc_error** error) {
   GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
   auto retry_policy =
@@ -262,13 +262,13 @@ const char* ParseHealthCheckConfig(const grpc_json* field, grpc_error** error) {
 
 }  // namespace
 
-UniquePtr<ServiceConfig::ParsedConfig>
+std::unique_ptr<ServiceConfig::ParsedConfig>
 ClientChannelServiceConfigParser::ParseGlobalParams(const grpc_json* json,
                                                     grpc_error** error) {
   GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
   InlinedVector<grpc_error*, 4> error_list;
   RefCountedPtr<LoadBalancingPolicy::Config> parsed_lb_config;
-  UniquePtr<char> lb_policy_name;
+  grpc_core::UniquePtr<char> lb_policy_name;
   Optional<ClientChannelGlobalParsedConfig::RetryThrottling> retry_throttling;
   const char* health_check_service_name = nullptr;
   for (grpc_json* field = json->child; field != nullptr; field = field->next) {
@@ -445,14 +445,14 @@ ClientChannelServiceConfigParser::ParseGlobalParams(const grpc_json* json,
   return nullptr;
 }
 
-UniquePtr<ServiceConfig::ParsedConfig>
+std::unique_ptr<ServiceConfig::ParsedConfig>
 ClientChannelServiceConfigParser::ParsePerMethodParams(const grpc_json* json,
                                                        grpc_error** error) {
   GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
   InlinedVector<grpc_error*, 4> error_list;
   Optional<bool> wait_for_ready;
   grpc_millis timeout = 0;
-  UniquePtr<ClientChannelMethodParsedConfig::RetryPolicy> retry_policy;
+  std::unique_ptr<ClientChannelMethodParsedConfig::RetryPolicy> retry_policy;
   for (grpc_json* field = json->child; field != nullptr; field = field->next) {
     if (field->key == nullptr) continue;
     if (strcmp(field->key, "waitForReady") == 0) {

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

@@ -46,7 +46,7 @@ class ClientChannelGlobalParsedConfig : public ServiceConfig::ParsedConfig {
 
   ClientChannelGlobalParsedConfig(
       RefCountedPtr<LoadBalancingPolicy::Config> parsed_lb_config,
-      UniquePtr<char> parsed_deprecated_lb_policy,
+      grpc_core::UniquePtr<char> parsed_deprecated_lb_policy,
       const Optional<RetryThrottling>& retry_throttling,
       const char* health_check_service_name)
       : parsed_lb_config_(std::move(parsed_lb_config)),
@@ -72,7 +72,7 @@ class ClientChannelGlobalParsedConfig : public ServiceConfig::ParsedConfig {
 
  private:
   RefCountedPtr<LoadBalancingPolicy::Config> parsed_lb_config_;
-  UniquePtr<char> parsed_deprecated_lb_policy_;
+  grpc_core::UniquePtr<char> parsed_deprecated_lb_policy_;
   Optional<RetryThrottling> retry_throttling_;
   const char* health_check_service_name_;
 };
@@ -89,7 +89,7 @@ class ClientChannelMethodParsedConfig : public ServiceConfig::ParsedConfig {
 
   ClientChannelMethodParsedConfig(grpc_millis timeout,
                                   const Optional<bool>& wait_for_ready,
-                                  UniquePtr<RetryPolicy> retry_policy)
+                                  std::unique_ptr<RetryPolicy> retry_policy)
       : timeout_(timeout),
         wait_for_ready_(wait_for_ready),
         retry_policy_(std::move(retry_policy)) {}
@@ -103,15 +103,15 @@ class ClientChannelMethodParsedConfig : public ServiceConfig::ParsedConfig {
  private:
   grpc_millis timeout_ = 0;
   Optional<bool> wait_for_ready_;
-  UniquePtr<RetryPolicy> retry_policy_;
+  std::unique_ptr<RetryPolicy> retry_policy_;
 };
 
 class ClientChannelServiceConfigParser : public ServiceConfig::Parser {
  public:
-  UniquePtr<ServiceConfig::ParsedConfig> ParseGlobalParams(
+  std::unique_ptr<ServiceConfig::ParsedConfig> ParseGlobalParams(
       const grpc_json* json, grpc_error** error) override;
 
-  UniquePtr<ServiceConfig::ParsedConfig> ParsePerMethodParams(
+  std::unique_ptr<ServiceConfig::ParsedConfig> ParsePerMethodParams(
       const grpc_json* json, grpc_error** error) override;
 
   static size_t ParserIndex();

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

@@ -114,7 +114,7 @@ class ResolvingLoadBalancingPolicy::ResolvingControlHelper
   }
 
   void UpdateState(grpc_connectivity_state state,
-                   UniquePtr<SubchannelPicker> picker) override {
+                   std::unique_ptr<SubchannelPicker> picker) override {
     if (parent_->resolver_ == nullptr) return;  // Shutting down.
     // If this request is from the pending child policy, ignore it until
     // it reports READY, at which point we swap it into place.
@@ -177,7 +177,7 @@ class ResolvingLoadBalancingPolicy::ResolvingControlHelper
 //
 
 ResolvingLoadBalancingPolicy::ResolvingLoadBalancingPolicy(
-    Args args, TraceFlag* tracer, UniquePtr<char> target_uri,
+    Args args, TraceFlag* tracer, grpc_core::UniquePtr<char> target_uri,
     ProcessResolverResultCallback process_resolver_result,
     void* process_resolver_result_user_data)
     : LoadBalancingPolicy(std::move(args)),
@@ -371,11 +371,11 @@ OrphanablePtr<LoadBalancingPolicy>
 ResolvingLoadBalancingPolicy::CreateLbPolicyLocked(
     const char* lb_policy_name, const grpc_channel_args& args,
     TraceStringVector* trace_strings) {
-  ResolvingControlHelper* helper = New<ResolvingControlHelper>(Ref());
+  ResolvingControlHelper* helper = new ResolvingControlHelper(Ref());
   LoadBalancingPolicy::Args lb_policy_args;
   lb_policy_args.combiner = combiner();
   lb_policy_args.channel_control_helper =
-      UniquePtr<ChannelControlHelper>(helper);
+      std::unique_ptr<ChannelControlHelper>(helper);
   lb_policy_args.args = &args;
   OrphanablePtr<LoadBalancingPolicy> lb_policy =
       LoadBalancingPolicyRegistry::CreateLoadBalancingPolicy(
@@ -425,7 +425,7 @@ void ResolvingLoadBalancingPolicy::ConcatenateAndAddChannelTraceLocked(
       gpr_strvec_add(&v, (*trace_strings)[i]);
     }
     size_t len = 0;
-    UniquePtr<char> message(gpr_strvec_flatten(&v, &len));
+    grpc_core::UniquePtr<char> message(gpr_strvec_flatten(&v, &len));
     channel_control_helper()->AddTraceEvent(ChannelControlHelper::TRACE_INFO,
                                             StringView(message.get()));
     gpr_strvec_destroy(&v);

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

@@ -65,7 +65,7 @@ class ResolvingLoadBalancingPolicy : public LoadBalancingPolicy {
   // If error is set when this returns, then construction failed, and
   // the caller may not use the new object.
   ResolvingLoadBalancingPolicy(
-      Args args, TraceFlag* tracer, UniquePtr<char> target_uri,
+      Args args, TraceFlag* tracer, grpc_core::UniquePtr<char> target_uri,
       ProcessResolverResultCallback process_resolver_result,
       void* process_resolver_result_user_data);
 
@@ -106,10 +106,10 @@ class ResolvingLoadBalancingPolicy : public LoadBalancingPolicy {
 
   // Passed in from caller at construction time.
   TraceFlag* tracer_;
-  UniquePtr<char> target_uri_;
+  grpc_core::UniquePtr<char> target_uri_;
   ProcessResolverResultCallback process_resolver_result_ = nullptr;
   void* process_resolver_result_user_data_ = nullptr;
-  UniquePtr<char> child_policy_name_;
+  grpc_core::UniquePtr<char> child_policy_name_;
   RefCountedPtr<LoadBalancingPolicy::Config> child_lb_config_;
 
   // Resolver and associated state.

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

@@ -34,7 +34,7 @@
 namespace grpc_core {
 
 namespace {
-typedef InlinedVector<UniquePtr<ServiceConfig::Parser>,
+typedef InlinedVector<std::unique_ptr<ServiceConfig::Parser>,
                       ServiceConfig::kNumPreallocatedParsers>
     ServiceConfigParserList;
 ServiceConfigParserList* g_registered_parsers;
@@ -42,8 +42,8 @@ ServiceConfigParserList* g_registered_parsers;
 
 RefCountedPtr<ServiceConfig> ServiceConfig::Create(const char* json,
                                                    grpc_error** error) {
-  UniquePtr<char> service_config_json(gpr_strdup(json));
-  UniquePtr<char> json_string(gpr_strdup(json));
+  grpc_core::UniquePtr<char> service_config_json(gpr_strdup(json));
+  grpc_core::UniquePtr<char> json_string(gpr_strdup(json));
   GPR_DEBUG_ASSERT(error != nullptr);
   grpc_json* json_tree = grpc_json_parse_string(json_string.get());
   if (json_tree == nullptr) {
@@ -55,9 +55,9 @@ RefCountedPtr<ServiceConfig> ServiceConfig::Create(const char* json,
       std::move(service_config_json), std::move(json_string), json_tree, error);
 }
 
-ServiceConfig::ServiceConfig(UniquePtr<char> service_config_json,
-                             UniquePtr<char> json_string, grpc_json* json_tree,
-                             grpc_error** error)
+ServiceConfig::ServiceConfig(grpc_core::UniquePtr<char> service_config_json,
+                             grpc_core::UniquePtr<char> json_string,
+                             grpc_json* json_tree, grpc_error** error)
     : service_config_json_(std::move(service_config_json)),
       json_string_(std::move(json_string)),
       json_tree_(json_tree) {
@@ -121,7 +121,7 @@ grpc_error* ServiceConfig::ParseJsonMethodConfigToServiceConfigVectorTable(
           [parsed_method_config_vectors_storage_.size() - 1]
               .get();
   // Construct list of paths.
-  InlinedVector<UniquePtr<char>, 10> paths;
+  InlinedVector<grpc_core::UniquePtr<char>, 10> paths;
   for (grpc_json* child = json->child; child != nullptr; child = child->next) {
     if (child->key == nullptr) continue;
     if (strcmp(child->key, "name") == 0) {
@@ -132,7 +132,8 @@ grpc_error* ServiceConfig::ParseJsonMethodConfigToServiceConfigVectorTable(
       }
       for (grpc_json* name = child->child; name != nullptr; name = name->next) {
         grpc_error* parse_error = GRPC_ERROR_NONE;
-        UniquePtr<char> path = ParseJsonMethodName(name, &parse_error);
+        grpc_core::UniquePtr<char> path =
+            ParseJsonMethodName(name, &parse_error);
         if (path == nullptr) {
           error_list.push_back(parse_error);
         } else {
@@ -228,8 +229,8 @@ int ServiceConfig::CountNamesInMethodConfig(grpc_json* json) {
   return num_names;
 }
 
-UniquePtr<char> ServiceConfig::ParseJsonMethodName(grpc_json* json,
-                                                   grpc_error** error) {
+grpc_core::UniquePtr<char> ServiceConfig::ParseJsonMethodName(
+    grpc_json* json, grpc_error** error) {
   if (json->type != GRPC_JSON_OBJECT) {
     *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "field:name error:type is not object");
@@ -282,7 +283,7 @@ UniquePtr<char> ServiceConfig::ParseJsonMethodName(grpc_json* json,
   char* path;
   gpr_asprintf(&path, "/%s/%s", service_name,
                method_name == nullptr ? "*" : method_name);
-  return UniquePtr<char>(path);
+  return grpc_core::UniquePtr<char>(path);
 }
 
 const ServiceConfig::ParsedConfigVector*
@@ -311,18 +312,18 @@ ServiceConfig::GetMethodParsedConfigVector(const grpc_slice& path) {
   return *value;
 }
 
-size_t ServiceConfig::RegisterParser(UniquePtr<Parser> parser) {
+size_t ServiceConfig::RegisterParser(std::unique_ptr<Parser> parser) {
   g_registered_parsers->push_back(std::move(parser));
   return g_registered_parsers->size() - 1;
 }
 
 void ServiceConfig::Init() {
   GPR_ASSERT(g_registered_parsers == nullptr);
-  g_registered_parsers = New<ServiceConfigParserList>();
+  g_registered_parsers = new ServiceConfigParserList();
 }
 
 void ServiceConfig::Shutdown() {
-  Delete(g_registered_parsers);
+  delete g_registered_parsers;
   g_registered_parsers = nullptr;
 }
 

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

@@ -69,7 +69,7 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
    public:
     virtual ~Parser() = default;
 
-    virtual UniquePtr<ParsedConfig> ParseGlobalParams(
+    virtual std::unique_ptr<ParsedConfig> ParseGlobalParams(
         const grpc_json* /* json */, grpc_error** error) {
       // Avoid unused parameter warning on debug-only parameter
       (void)error;
@@ -77,7 +77,7 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
       return nullptr;
     }
 
-    virtual UniquePtr<ParsedConfig> ParsePerMethodParams(
+    virtual std::unique_ptr<ParsedConfig> ParsePerMethodParams(
         const grpc_json* /* json */, grpc_error** error) {
       // Avoid unused parameter warning on debug-only parameter
       (void)error;
@@ -87,7 +87,7 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
   };
 
   static constexpr int kNumPreallocatedParsers = 4;
-  typedef InlinedVector<UniquePtr<ParsedConfig>, kNumPreallocatedParsers>
+  typedef InlinedVector<std::unique_ptr<ParsedConfig>, kNumPreallocatedParsers>
       ParsedConfigVector;
 
   /// When a service config is applied to a call in the client_channel_filter,
@@ -128,6 +128,10 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
   static RefCountedPtr<ServiceConfig> Create(const char* json,
                                              grpc_error** error);
 
+  // Takes ownership of \a json_tree.
+  ServiceConfig(grpc_core::UniquePtr<char> service_config_json,
+                grpc_core::UniquePtr<char> json_string, grpc_json* json_tree,
+                grpc_error** error);
   ~ServiceConfig();
 
   const char* service_config_json() const { return service_config_json_.get(); }
@@ -151,22 +155,13 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
   /// registered parser. Each parser is responsible for reading the service
   /// config json and returning a parsed config. This parsed config can later be
   /// retrieved using the same index that was returned at registration time.
-  static size_t RegisterParser(UniquePtr<Parser> parser);
+  static size_t RegisterParser(std::unique_ptr<Parser> parser);
 
   static void Init();
 
   static void Shutdown();
 
  private:
-  // So New() can call our private ctor.
-  template <typename T, typename... Args>
-  friend T* New(Args&&... args);
-
-  // Takes ownership of \a json_tree.
-  ServiceConfig(UniquePtr<char> service_config_json,
-                UniquePtr<char> json_string, grpc_json* json_tree,
-                grpc_error** error);
-
   // Helper functions to parse the service config
   grpc_error* ParseGlobalParams(const grpc_json* json_tree);
   grpc_error* ParsePerMethodParams(const grpc_json* json_tree);
@@ -176,18 +171,18 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
 
   // Returns a path string for the JSON name object specified by \a json.
   // Returns null on error, and stores error in \a error.
-  static UniquePtr<char> ParseJsonMethodName(grpc_json* json,
-                                             grpc_error** error);
+  static grpc_core::UniquePtr<char> ParseJsonMethodName(grpc_json* json,
+                                                        grpc_error** error);
 
   grpc_error* ParseJsonMethodConfigToServiceConfigVectorTable(
       const grpc_json* json,
       SliceHashTable<const ParsedConfigVector*>::Entry* entries, size_t* idx);
 
-  UniquePtr<char> service_config_json_;
-  UniquePtr<char> json_string_;  // Underlying storage for json_tree.
+  grpc_core::UniquePtr<char> service_config_json_;
+  grpc_core::UniquePtr<char> json_string_;  // Underlying storage for json_tree.
   grpc_json* json_tree_;
 
-  InlinedVector<UniquePtr<ParsedConfig>, kNumPreallocatedParsers>
+  InlinedVector<std::unique_ptr<ParsedConfig>, kNumPreallocatedParsers>
       parsed_global_configs_;
   // A map from the method name to the parsed config vector. Note that we are
   // using a raw pointer and not a unique pointer so that we can use the same
@@ -196,7 +191,7 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
       parsed_method_configs_table_;
   // Storage for all the vectors that are being used in
   // parsed_method_configs_table_.
-  InlinedVector<UniquePtr<ParsedConfigVector>, 32>
+  InlinedVector<std::unique_ptr<ParsedConfigVector>, 32>
       parsed_method_config_vectors_storage_;
 };
 

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

@@ -213,11 +213,12 @@ void SubchannelCall::Unref() {
   GRPC_CALL_STACK_UNREF(SUBCHANNEL_CALL_TO_CALL_STACK(this), "");
 }
 
-void SubchannelCall::Unref(const DebugLocation& location, const char* reason) {
+void SubchannelCall::Unref(const DebugLocation& /*location*/,
+                           const char* reason) {
   GRPC_CALL_STACK_UNREF(SUBCHANNEL_CALL_TO_CALL_STACK(this), reason);
 }
 
-void SubchannelCall::Destroy(void* arg, grpc_error* error) {
+void SubchannelCall::Destroy(void* arg, grpc_error* /*error*/) {
   GPR_TIMER_SCOPE("subchannel_call_destroy", 0);
   SubchannelCall* self = static_cast<SubchannelCall*>(arg);
   // Keep some members before destroying the subchannel call.
@@ -292,16 +293,16 @@ void SubchannelCall::RecvTrailingMetadataReady(void* arg, grpc_error* error) {
   } else {
     channelz_subchannel->RecordCallFailed();
   }
-  GRPC_CLOSURE_RUN(call->original_recv_trailing_metadata_,
-                   GRPC_ERROR_REF(error));
+  Closure::Run(DEBUG_LOCATION, call->original_recv_trailing_metadata_,
+               GRPC_ERROR_REF(error));
 }
 
 void SubchannelCall::IncrementRefCount() {
   GRPC_CALL_STACK_REF(SUBCHANNEL_CALL_TO_CALL_STACK(this), "");
 }
 
-void SubchannelCall::IncrementRefCount(const grpc_core::DebugLocation& location,
-                                       const char* reason) {
+void SubchannelCall::IncrementRefCount(
+    const grpc_core::DebugLocation& /*location*/, const char* reason) {
   GRPC_CALL_STACK_REF(SUBCHANNEL_CALL_TO_CALL_STACK(this), reason);
 }
 
@@ -403,7 +404,8 @@ void Subchannel::ConnectivityStateWatcherList::NotifyLocked(
 class Subchannel::HealthWatcherMap::HealthWatcher
     : public AsyncConnectivityStateWatcherInterface {
  public:
-  HealthWatcher(Subchannel* c, UniquePtr<char> health_check_service_name,
+  HealthWatcher(Subchannel* c,
+                grpc_core::UniquePtr<char> health_check_service_name,
                 grpc_connectivity_state subchannel_state)
       : subchannel_(c),
         health_check_service_name_(std::move(health_check_service_name)),
@@ -488,7 +490,7 @@ class Subchannel::HealthWatcherMap::HealthWatcher
   }
 
   Subchannel* subchannel_;
-  UniquePtr<char> health_check_service_name_;
+  grpc_core::UniquePtr<char> health_check_service_name_;
   OrphanablePtr<HealthCheckClient> health_check_client_;
   grpc_connectivity_state state_;
   ConnectivityStateWatcherList watcher_list_;
@@ -500,7 +502,7 @@ class Subchannel::HealthWatcherMap::HealthWatcher
 
 void Subchannel::HealthWatcherMap::AddWatcherLocked(
     Subchannel* subchannel, grpc_connectivity_state initial_state,
-    UniquePtr<char> health_check_service_name,
+    grpc_core::UniquePtr<char> health_check_service_name,
     OrphanablePtr<ConnectivityStateWatcherInterface> watcher) {
   // If the health check service name is not already present in the map,
   // add it.
@@ -611,21 +613,21 @@ BackOff::Options ParseArgsForBackoffValues(
 
 }  // namespace
 
-Subchannel::Subchannel(SubchannelKey* key, grpc_connector* connector,
+Subchannel::Subchannel(SubchannelKey* key,
+                       OrphanablePtr<SubchannelConnector> connector,
                        const grpc_channel_args* args)
     : key_(key),
-      connector_(connector),
+      connector_(std::move(connector)),
       backoff_(ParseArgsForBackoffValues(args, &min_connect_timeout_ms_)) {
   GRPC_STATS_INC_CLIENT_SUBCHANNELS_CREATED();
   gpr_atm_no_barrier_store(&ref_pair_, 1 << INTERNAL_REF_BITS);
-  grpc_connector_ref(connector_);
   pollset_set_ = grpc_pollset_set_create();
   grpc_resolved_address* addr =
       static_cast<grpc_resolved_address*>(gpr_malloc(sizeof(*addr)));
   GetAddressFromSubchannelAddressArg(args, addr);
   grpc_resolved_address* new_address = nullptr;
   grpc_channel_args* new_args = nullptr;
-  if (grpc_proxy_mappers_map_address(addr, args, &new_address, &new_args)) {
+  if (ProxyMapperRegistry::MapAddress(*addr, args, &new_address, &new_args)) {
     GPR_ASSERT(new_address != nullptr);
     gpr_free(addr);
     addr = new_address;
@@ -666,23 +668,23 @@ Subchannel::~Subchannel() {
     channelz_node_->UpdateConnectivityState(GRPC_CHANNEL_SHUTDOWN);
   }
   grpc_channel_args_destroy(args_);
-  grpc_connector_unref(connector_);
+  connector_.reset();
   grpc_pollset_set_destroy(pollset_set_);
-  Delete(key_);
+  delete key_;
 }
 
-Subchannel* Subchannel::Create(grpc_connector* connector,
+Subchannel* Subchannel::Create(OrphanablePtr<SubchannelConnector> connector,
                                const grpc_channel_args* args) {
-  SubchannelKey* key = New<SubchannelKey>(args);
+  SubchannelKey* key = new SubchannelKey(args);
   SubchannelPoolInterface* subchannel_pool =
       SubchannelPoolInterface::GetSubchannelPoolFromChannelArgs(args);
   GPR_ASSERT(subchannel_pool != nullptr);
   Subchannel* c = subchannel_pool->FindSubchannel(key);
   if (c != nullptr) {
-    Delete(key);
+    delete key;
     return c;
   }
-  c = New<Subchannel>(key, connector, args);
+  c = new Subchannel(key, std::move(connector), args);
   // Try to register the subchannel before setting the subchannel pool.
   // Otherwise, in case of a registration race, unreffing c in
   // RegisterSubchannel() will cause c to be tried to be unregistered, while
@@ -721,9 +723,9 @@ Subchannel* Subchannel::WeakRef(GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
 
 namespace {
 
-void subchannel_destroy(void* arg, grpc_error* error) {
+void subchannel_destroy(void* arg, grpc_error* /*error*/) {
   Subchannel* self = static_cast<Subchannel*>(arg);
-  Delete(self);
+  delete self;
 }
 
 }  // namespace
@@ -733,13 +735,14 @@ void Subchannel::WeakUnref(GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
   old_refs = RefMutate(-static_cast<gpr_atm>(1),
                        1 GRPC_SUBCHANNEL_REF_MUTATE_PURPOSE("WEAK_UNREF"));
   if (old_refs == 1) {
-    GRPC_CLOSURE_SCHED(GRPC_CLOSURE_CREATE(subchannel_destroy, this,
-                                           grpc_schedule_on_exec_ctx),
-                       GRPC_ERROR_NONE);
+    ExecCtx::Run(DEBUG_LOCATION,
+                 GRPC_CLOSURE_CREATE(subchannel_destroy, this,
+                                     grpc_schedule_on_exec_ctx),
+                 GRPC_ERROR_NONE);
   }
 }
 
-Subchannel* Subchannel::RefFromWeakRef(GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
+Subchannel* Subchannel::RefFromWeakRef() {
   for (;;) {
     gpr_atm old_refs = gpr_atm_acq_load(&ref_pair_);
     if (old_refs >= (1 << INTERNAL_REF_BITS)) {
@@ -784,7 +787,7 @@ grpc_connectivity_state Subchannel::CheckConnectivityState(
 
 void Subchannel::WatchConnectivityState(
     grpc_connectivity_state initial_state,
-    UniquePtr<char> health_check_service_name,
+    grpc_core::UniquePtr<char> health_check_service_name,
     OrphanablePtr<ConnectivityStateWatcherInterface> watcher) {
   MutexLock lock(&mu_);
   grpc_pollset_set* interested_parties = watcher->interested_parties();
@@ -972,7 +975,7 @@ void Subchannel::OnRetryAlarm(void* arg, grpc_error* error) {
 }
 
 void Subchannel::ContinueConnectingLocked() {
-  grpc_connect_in_args args;
+  SubchannelConnector::Args args;
   args.interested_parties = pollset_set_;
   const grpc_millis min_deadline =
       min_connect_timeout_ms_ + ExecCtx::Get()->Now();
@@ -980,13 +983,13 @@ void Subchannel::ContinueConnectingLocked() {
   args.deadline = std::max(next_attempt_deadline_, min_deadline);
   args.channel_args = args_;
   SetConnectivityStateLocked(GRPC_CHANNEL_CONNECTING);
-  grpc_connector_connect(connector_, &args, &connecting_result_,
-                         &on_connecting_finished_);
+  connector_->Connect(args, &connecting_result_, &on_connecting_finished_);
 }
 
 void Subchannel::OnConnectingFinished(void* arg, grpc_error* error) {
   auto* c = static_cast<Subchannel*>(arg);
-  grpc_channel_args* delete_channel_args = c->connecting_result_.channel_args;
+  const grpc_channel_args* delete_channel_args =
+      c->connecting_result_.channel_args;
   GRPC_SUBCHANNEL_WEAK_REF(c, "on_connecting_finished");
   {
     MutexLock lock(&c->mu_);
@@ -1008,7 +1011,7 @@ void Subchannel::OnConnectingFinished(void* arg, grpc_error* error) {
 
 namespace {
 
-void ConnectionDestroy(void* arg, grpc_error* error) {
+void ConnectionDestroy(void* arg, grpc_error* /*error*/) {
   grpc_channel_stack* stk = static_cast<grpc_channel_stack*>(arg);
   grpc_channel_stack_destroy(stk);
   gpr_free(stk);
@@ -1039,8 +1042,8 @@ bool Subchannel::PublishTransportLocked() {
     return false;
   }
   RefCountedPtr<channelz::SocketNode> socket =
-      std::move(connecting_result_.socket);
-  connecting_result_.reset();
+      std::move(connecting_result_.socket_node);
+  connecting_result_.Reset();
   if (disconnected_) {
     grpc_channel_stack_destroy(stk);
     gpr_free(stk);
@@ -1048,7 +1051,7 @@ bool Subchannel::PublishTransportLocked() {
   }
   // Publish.
   connected_subchannel_.reset(
-      New<ConnectedSubchannel>(stk, args_, channelz_node_));
+      new ConnectedSubchannel(stk, args_, channelz_node_));
   gpr_log(GPR_INFO, "New connected subchannel at %p for subchannel %p",
           connected_subchannel_.get(), this);
   if (channelz_node_ != nullptr) {
@@ -1072,8 +1075,7 @@ void Subchannel::Disconnect() {
   MutexLock lock(&mu_);
   GPR_ASSERT(!disconnected_);
   disconnected_ = true;
-  grpc_connector_shutdown(connector_, GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                                          "Subchannel disconnected"));
+  connector_.reset();
   connected_subchannel_.reset();
   health_watcher_map_.ShutdownLocked();
 }