Use health check parser

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

@@ -438,13 +438,15 @@ class ClientChannelControlHelper
                              "ClientChannelControlHelper");
   }
 
-  Subchannel* CreateSubchannel(const grpc_channel_args& args) override {
+  Subchannel* CreateSubchannel(
+      const grpc_channel_args& args,
+      const HealthCheckParsedObject* health_check) override {
     grpc_arg arg = SubchannelPoolInterface::CreateChannelArg(
         chand_->subchannel_pool.get());
     grpc_channel_args* new_args =
         grpc_channel_args_copy_and_add(&args, &arg, 1);
-    Subchannel* subchannel =
-        chand_->client_channel_factory->CreateSubchannel(new_args);
+    Subchannel* subchannel = chand_->client_channel_factory->CreateSubchannel(
+        new_args, health_check);
     grpc_channel_args_destroy(new_args);
     return subchannel;
   }
@@ -491,7 +493,8 @@ class ClientChannelControlHelper
 // result update.
 static bool process_resolver_result_locked(
     void* arg, grpc_core::Resolver::Result* result, const char** lb_policy_name,
-    const grpc_core::ParsedLoadBalancingConfig** lb_policy_config) {
+    const grpc_core::ParsedLoadBalancingConfig** lb_policy_config,
+    const grpc_core::HealthCheckParsedObject** health_check) {
   channel_data* chand = static_cast<channel_data*>(arg);
   ProcessedResolverResult resolver_result(result, chand->enable_retries);
   const char* service_config_json = resolver_result.service_config_json();
@@ -517,6 +520,7 @@ static bool process_resolver_result_locked(
   // Return results.
   *lb_policy_name = chand->info_lb_policy_name.get();
   *lb_policy_config = resolver_result.lb_policy_config();
+  *health_check = resolver_result.health_check();
   return service_config_changed;
 }
 

src/core/ext/filters/client_channel/client_channel_factory.h

@@ -23,6 +23,7 @@
 
 #include <grpc/impl/codegen/grpc_types.h>
 
+#include "src/core/ext/filters/client_channel/health/health_check_parser.h"
 #include "src/core/ext/filters/client_channel/subchannel.h"
 #include "src/core/lib/gprpp/abstract.h"
 
@@ -33,8 +34,9 @@ class ClientChannelFactory {
   virtual ~ClientChannelFactory() = default;
 
   // Creates a subchannel with the specified args.
-  virtual Subchannel* CreateSubchannel(const grpc_channel_args* args)
-      GRPC_ABSTRACT;
+  virtual Subchannel* CreateSubchannel(
+      const grpc_channel_args* args,
+      const HealthCheckParsedObject* health_check) GRPC_ABSTRACT;
 
   // Creates a channel for the specified target with the specified args.
   virtual grpc_channel* CreateChannel(

src/core/ext/filters/client_channel/client_channel_plugin.cc

@@ -27,6 +27,7 @@
 #include "src/core/ext/filters/client_channel/client_channel.h"
 #include "src/core/ext/filters/client_channel/client_channel_channelz.h"
 #include "src/core/ext/filters/client_channel/global_subchannel_pool.h"
+#include "src/core/ext/filters/client_channel/health/health_check_parser.h"
 #include "src/core/ext/filters/client_channel/http_connect_handshaker.h"
 #include "src/core/ext/filters/client_channel/http_proxy.h"
 #include "src/core/ext/filters/client_channel/lb_policy_registry.h"
@@ -53,6 +54,7 @@ static bool append_filter(grpc_channel_stack_builder* builder, void* arg) {
 void grpc_service_config_register_parsers() {
   grpc_core::internal::ClientChannelServiceConfigParser::Register();
   grpc_core::MessageSizeParser::Register();
+  grpc_core::HealthCheckParser::Register();
 }
 
 void grpc_client_channel_init(void) {

src/core/ext/filters/client_channel/lb_policy.cc

@@ -117,12 +117,15 @@ grpc_json* LoadBalancingPolicy::ParseLoadBalancingConfig(
 LoadBalancingPolicy::UpdateArgs::UpdateArgs(const UpdateArgs& other) {
   addresses = other.addresses;
   config = other.config;
+  health_check = other.health_check;
   args = grpc_channel_args_copy(other.args);
 }
 
 LoadBalancingPolicy::UpdateArgs::UpdateArgs(UpdateArgs&& other) {
   addresses = std::move(other.addresses);
   config = std::move(other.config);
+  health_check = other.health_check;
+  other.health_check = nullptr;
   // TODO(roth): Use std::move() once channel args is converted to C++.
   args = other.args;
   other.args = nullptr;
@@ -132,6 +135,7 @@ LoadBalancingPolicy::UpdateArgs& LoadBalancingPolicy::UpdateArgs::operator=(
     const UpdateArgs& other) {
   addresses = other.addresses;
   config = other.config;
+  health_check = other.health_check;
   grpc_channel_args_destroy(args);
   args = grpc_channel_args_copy(other.args);
   return *this;
@@ -141,6 +145,8 @@ LoadBalancingPolicy::UpdateArgs& LoadBalancingPolicy::UpdateArgs::operator=(
     UpdateArgs&& other) {
   addresses = std::move(other.addresses);
   config = std::move(other.config);
+  health_check = other.health_check;
+  other.health_check = nullptr;
   // TODO(roth): Use std::move() once channel args is converted to C++.
   grpc_channel_args_destroy(args);
   args = other.args;

src/core/ext/filters/client_channel/lb_policy.h

@@ -175,8 +175,9 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     virtual ~ChannelControlHelper() = default;
 
     /// Creates a new subchannel with the specified channel args.
-    virtual Subchannel* CreateSubchannel(const grpc_channel_args& args)
-        GRPC_ABSTRACT;
+    virtual Subchannel* CreateSubchannel(
+        const grpc_channel_args& args,
+        const HealthCheckParsedObject* health_check) GRPC_ABSTRACT;
 
     /// Creates a channel with the specified target and channel args.
     /// This can be used in cases where the LB policy needs to create a
@@ -201,6 +202,7 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
   struct UpdateArgs {
     ServerAddressList addresses;
     const ParsedLoadBalancingConfig* config = nullptr;
+    const HealthCheckParsedObject* health_check = nullptr;
     const grpc_channel_args* args = nullptr;
 
     // TODO(roth): Remove everything below once channel args is

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

@@ -295,7 +295,9 @@ class GrpcLb : public LoadBalancingPolicy {
     explicit Helper(RefCountedPtr<GrpcLb> parent)
         : parent_(std::move(parent)) {}
 
-    Subchannel* CreateSubchannel(const grpc_channel_args& args) override;
+    Subchannel* CreateSubchannel(
+        const grpc_channel_args& args,
+        const HealthCheckParsedObject* health_check) override;
     grpc_channel* CreateChannel(const char* target,
                                 const grpc_channel_args& args) override;
     void UpdateState(grpc_connectivity_state state, grpc_error* state_error,
@@ -620,12 +622,15 @@ bool GrpcLb::Helper::CalledByCurrentChild() const {
   return child_ == parent_->child_policy_.get();
 }
 
-Subchannel* GrpcLb::Helper::CreateSubchannel(const grpc_channel_args& args) {
+Subchannel* GrpcLb::Helper::CreateSubchannel(
+    const grpc_channel_args& args,
+    const HealthCheckParsedObject* health_check) {
   if (parent_->shutting_down_ ||
       (!CalledByPendingChild() && !CalledByCurrentChild())) {
     return nullptr;
   }
-  return parent_->channel_control_helper()->CreateSubchannel(args);
+  return parent_->channel_control_helper()->CreateSubchannel(args,
+                                                             health_check);
 }
 
 grpc_channel* GrpcLb::Helper::CreateChannel(const char* target,

src/core/ext/filters/client_channel/lb_policy/pick_first/pick_first.cc

@@ -88,9 +88,10 @@ class PickFirst : public LoadBalancingPolicy {
     PickFirstSubchannelList(PickFirst* policy, TraceFlag* tracer,
                             const ServerAddressList& addresses,
                             grpc_combiner* combiner,
-                            const grpc_channel_args& args)
+                            const grpc_channel_args& args,
+                            const HealthCheckParsedObject* health_check)
         : SubchannelList(policy, tracer, addresses, combiner,
-                         policy->channel_control_helper(), args) {
+                         policy->channel_control_helper(), args, health_check) {
       // Need to maintain a ref to the LB policy as long as we maintain
       // any references to subchannels, since the subchannels'
       // pollset_sets will include the LB policy's pollset_set.
@@ -254,7 +255,8 @@ void PickFirst::UpdateLocked(UpdateArgs args) {
   grpc_channel_args* new_args =
       grpc_channel_args_copy_and_add(args.args, &new_arg, 1);
   auto subchannel_list = MakeOrphanable<PickFirstSubchannelList>(
-      this, &grpc_lb_pick_first_trace, args.addresses, combiner(), *new_args);
+      this, &grpc_lb_pick_first_trace, args.addresses, combiner(), *new_args,
+      args.health_check);
   grpc_channel_args_destroy(new_args);
   if (subchannel_list->num_subchannels() == 0) {
     // Empty update or no valid subchannels. Unsubscribe from all current

src/core/ext/filters/client_channel/lb_policy/round_robin/round_robin.cc

@@ -109,9 +109,10 @@ class RoundRobin : public LoadBalancingPolicy {
     RoundRobinSubchannelList(RoundRobin* policy, TraceFlag* tracer,
                              const ServerAddressList& addresses,
                              grpc_combiner* combiner,
-                             const grpc_channel_args& args)
+                             const grpc_channel_args& args,
+                             const HealthCheckParsedObject* health_check)
         : SubchannelList(policy, tracer, addresses, combiner,
-                         policy->channel_control_helper(), args) {
+                         policy->channel_control_helper(), args, health_check) {
       // Need to maintain a ref to the LB policy as long as we maintain
       // any references to subchannels, since the subchannels'
       // pollset_sets will include the LB policy's pollset_set.
@@ -488,7 +489,8 @@ void RoundRobin::UpdateLocked(UpdateArgs args) {
     }
   }
   latest_pending_subchannel_list_ = MakeOrphanable<RoundRobinSubchannelList>(
-      this, &grpc_lb_round_robin_trace, args.addresses, combiner(), *args.args);
+      this, &grpc_lb_round_robin_trace, args.addresses, combiner(), *args.args,
+      args.health_check);
   if (latest_pending_subchannel_list_->num_subchannels() == 0) {
     // If the new list is empty, immediately promote the new list to the
     // current list and transition to TRANSIENT_FAILURE.

src/core/ext/filters/client_channel/lb_policy/subchannel_list.h

@@ -233,7 +233,8 @@ class SubchannelList : public InternallyRefCounted<SubchannelListType> {
   SubchannelList(LoadBalancingPolicy* policy, TraceFlag* tracer,
                  const ServerAddressList& addresses, grpc_combiner* combiner,
                  LoadBalancingPolicy::ChannelControlHelper* helper,
-                 const grpc_channel_args& args);
+                 const grpc_channel_args& args,
+                 const HealthCheckParsedObject* health_check);
 
   virtual ~SubchannelList();
 
@@ -487,7 +488,7 @@ SubchannelList<SubchannelListType, SubchannelDataType>::SubchannelList(
     LoadBalancingPolicy* policy, TraceFlag* tracer,
     const ServerAddressList& addresses, grpc_combiner* combiner,
     LoadBalancingPolicy::ChannelControlHelper* helper,
-    const grpc_channel_args& args)
+    const grpc_channel_args& args, const HealthCheckParsedObject* health_check)
     : InternallyRefCounted<SubchannelListType>(tracer),
       policy_(policy),
       tracer_(tracer),
@@ -522,7 +523,7 @@ SubchannelList<SubchannelListType, SubchannelDataType>::SubchannelList(
         &args, keys_to_remove, GPR_ARRAY_SIZE(keys_to_remove),
         args_to_add.data(), args_to_add.size());
     gpr_free(args_to_add[subchannel_address_arg_index].value.string);
-    Subchannel* subchannel = helper->CreateSubchannel(*new_args);
+    Subchannel* subchannel = helper->CreateSubchannel(*new_args, health_check);
     grpc_channel_args_destroy(new_args);
     if (subchannel == nullptr) {
       // Subchannel could not be created.

src/core/ext/filters/client_channel/lb_policy/xds/xds.cc

@@ -328,7 +328,9 @@ class XdsLb : public LoadBalancingPolicy {
         explicit Helper(RefCountedPtr<LocalityEntry> entry)
             : entry_(std::move(entry)) {}
 
-        Subchannel* CreateSubchannel(const grpc_channel_args& args) override;
+        Subchannel* CreateSubchannel(
+            const grpc_channel_args& args,
+            const HealthCheckParsedObject* health_check) override;
         grpc_channel* CreateChannel(const char* target,
                                     const grpc_channel_args& args) override;
         void UpdateState(grpc_connectivity_state state, grpc_error* state_error,
@@ -1576,12 +1578,14 @@ bool XdsLb::LocalityMap::LocalityEntry::Helper::CalledByCurrentChild() const {
 }
 
 Subchannel* XdsLb::LocalityMap::LocalityEntry::Helper::CreateSubchannel(
-    const grpc_channel_args& args) {
+    const grpc_channel_args& args,
+    const HealthCheckParsedObject* health_check) {
   if (entry_->parent_->shutting_down_ ||
       (!CalledByPendingChild() && !CalledByCurrentChild())) {
     return nullptr;
   }
-  return entry_->parent_->channel_control_helper()->CreateSubchannel(args);
+  return entry_->parent_->channel_control_helper()->CreateSubchannel(
+      args, health_check);
 }
 
 grpc_channel* XdsLb::LocalityMap::LocalityEntry::Helper::CreateChannel(

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

@@ -108,6 +108,9 @@ grpc_error* CreateErrorFromVector(const char* desc,
 void ProcessedResolverResult::ProcessServiceConfig(
     const Resolver::Result& resolver_result, bool parse_retry) {
   if (service_config_ == nullptr) return;
+  health_check_ = static_cast<HealthCheckParsedObject*>(
+      service_config_->GetParsedGlobalServiceConfigObject(
+          HealthCheckParser::ParserIndex()));
   service_config_json_ = service_config_->service_config_json();
   auto* parsed_object = static_cast<ClientChannelGlobalParsedObject*>(
       service_config_->GetParsedGlobalServiceConfigObject(
@@ -559,12 +562,10 @@ ClientChannelServiceConfigParser::ParsePerMethodParams(const grpc_json* json,
   }
   *error = CreateErrorFromVector("Client channel parser", &error_list);
   if (*error == GRPC_ERROR_NONE) {
-    gpr_log(GPR_ERROR, "hura");
     return UniquePtr<ServiceConfigParsedObject>(
         New<ClientChannelMethodParsedObject>(timeout, wait_for_ready,
                                              std::move(retry_policy)));
   }
-  gpr_log(GPR_ERROR, "hura");
   return nullptr;
 }
 

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

@@ -140,6 +140,8 @@ class ProcessedResolverResult {
   const ParsedLoadBalancingConfig* lb_policy_config() {
     return lb_policy_config_;
   }
+
+  const HealthCheckParsedObject* health_check() { return health_check_; }
   RefCountedPtr<ServiceConfig> service_config() { return service_config_; }
 
  private:
@@ -169,6 +171,7 @@ class ProcessedResolverResult {
   // Retry throttle data.
   char* server_name_ = nullptr;
   RefCountedPtr<ServerRetryThrottleData> retry_throttle_data_;
+  const HealthCheckParsedObject* health_check_ = nullptr;
 };
 
 }  // namespace internal

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

@@ -106,10 +106,13 @@ class ResolvingLoadBalancingPolicy::ResolvingControlHelper
       RefCountedPtr<ResolvingLoadBalancingPolicy> parent)
       : parent_(std::move(parent)) {}
 
-  Subchannel* CreateSubchannel(const grpc_channel_args& args) override {
+  Subchannel* CreateSubchannel(
+      const grpc_channel_args& args,
+      const HealthCheckParsedObject* health_check) override {
     if (parent_->resolver_ == nullptr) return nullptr;  // Shutting down.
     if (!CalledByCurrentChild() && !CalledByPendingChild()) return nullptr;
-    return parent_->channel_control_helper()->CreateSubchannel(args);
+    return parent_->channel_control_helper()->CreateSubchannel(args,
+                                                               health_check);
   }
 
   grpc_channel* CreateChannel(const char* target,
@@ -343,7 +346,8 @@ void ResolvingLoadBalancingPolicy::OnResolverError(grpc_error* error) {
 void ResolvingLoadBalancingPolicy::CreateOrUpdateLbPolicyLocked(
     const char* lb_policy_name,
     const ParsedLoadBalancingConfig* lb_policy_config, Resolver::Result result,
-    TraceStringVector* trace_strings) {
+    TraceStringVector* trace_strings,
+    const HealthCheckParsedObject* health_check) {
   // If the child policy name changes, we need to create a new child
   // policy.  When this happens, we leave child_policy_ as-is and store
   // the new child policy in pending_child_policy_.  Once the new child
@@ -436,6 +440,7 @@ void ResolvingLoadBalancingPolicy::CreateOrUpdateLbPolicyLocked(
   UpdateArgs update_args;
   update_args.addresses = std::move(result.addresses);
   update_args.config = std::move(lb_policy_config);
+  update_args.health_check = health_check;
   // TODO(roth): Once channel args is converted to C++, use std::move() here.
   update_args.args = result.args;
   result.args = nullptr;
@@ -540,11 +545,12 @@ void ResolvingLoadBalancingPolicy::OnResolverResultChangedLocked(
   // Process the resolver result.
   const char* lb_policy_name = nullptr;
   const ParsedLoadBalancingConfig* lb_policy_config = nullptr;
+  const HealthCheckParsedObject* health_check = nullptr;
   bool service_config_changed = false;
   if (process_resolver_result_ != nullptr) {
-    service_config_changed =
-        process_resolver_result_(process_resolver_result_user_data_, &result,
-                                 &lb_policy_name, &lb_policy_config);
+    service_config_changed = process_resolver_result_(
+        process_resolver_result_user_data_, &result, &lb_policy_name,
+        &lb_policy_config, &health_check);
   } else {
     lb_policy_name = child_policy_name_.get();
     lb_policy_config = child_lb_config_;
@@ -552,7 +558,7 @@ void ResolvingLoadBalancingPolicy::OnResolverResultChangedLocked(
   GPR_ASSERT(lb_policy_name != nullptr);
   // Create or update LB policy, as needed.
   CreateOrUpdateLbPolicyLocked(lb_policy_name, lb_policy_config,
-                               std::move(result), &trace_strings);
+                               std::move(result), &trace_strings, health_check);
   // Add channel trace event.
   if (channelz_node() != nullptr) {
     if (service_config_changed) {

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

@@ -67,7 +67,8 @@ class ResolvingLoadBalancingPolicy : public LoadBalancingPolicy {
   // Returns true if the service config has changed since the last result.
   typedef bool (*ProcessResolverResultCallback)(
       void* user_data, Resolver::Result* result, const char** lb_policy_name,
-      const ParsedLoadBalancingConfig** lb_policy_config);
+      const ParsedLoadBalancingConfig** lb_policy_config,
+      const HealthCheckParsedObject** health_check);
   // If error is set when this returns, then construction failed, and
   // the caller may not use the new object.
   ResolvingLoadBalancingPolicy(
@@ -106,7 +107,8 @@ class ResolvingLoadBalancingPolicy : public LoadBalancingPolicy {
   void CreateOrUpdateLbPolicyLocked(
       const char* lb_policy_name,
       const ParsedLoadBalancingConfig* lb_policy_config,
-      Resolver::Result result, TraceStringVector* trace_strings);
+      Resolver::Result result, TraceStringVector* trace_strings,
+      const HealthCheckParsedObject* health_check);
   OrphanablePtr<LoadBalancingPolicy> CreateLbPolicyLocked(
       const char* lb_policy_name, const grpc_channel_args& args,
       TraceStringVector* trace_strings);

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

@@ -532,29 +532,11 @@ BackOff::Options ParseArgsForBackoffValues(
       .set_max_backoff(max_backoff_ms);
 }
 
-struct HealthCheckParams {
-  UniquePtr<char> service_name;
-
-  static void Parse(const grpc_json* field, HealthCheckParams* params) {
-    if (strcmp(field->key, "healthCheckConfig") == 0) {
-      if (field->type != GRPC_JSON_OBJECT) return;
-      for (grpc_json* sub_field = field->child; sub_field != nullptr;
-           sub_field = sub_field->next) {
-        if (sub_field->key == nullptr) return;
-        if (strcmp(sub_field->key, "serviceName") == 0) {
-          if (params->service_name != nullptr) return;  // Duplicate.
-          if (sub_field->type != GRPC_JSON_STRING) return;
-          params->service_name.reset(gpr_strdup(sub_field->value));
-        }
-      }
-    }
-  }
-};
-
 }  // namespace
 
 Subchannel::Subchannel(SubchannelKey* key, grpc_connector* connector,
-                       const grpc_channel_args* args)
+                       const grpc_channel_args* args,
+                       const HealthCheckParsedObject* health_check)
     : key_(key),
       connector_(connector),
       backoff_(ParseArgsForBackoffValues(args, &min_connect_timeout_ms_)) {
@@ -586,20 +568,10 @@ Subchannel::Subchannel(SubchannelKey* key, grpc_connector* connector,
                                "subchannel");
   grpc_connectivity_state_init(&state_and_health_tracker_, GRPC_CHANNEL_IDLE,
                                "subchannel");
-  // Check whether we should enable health checking.
-  const char* service_config_json = grpc_channel_arg_get_string(
-      grpc_channel_args_find(args_, GRPC_ARG_SERVICE_CONFIG));
-  if (service_config_json != nullptr) {
-    grpc_error* service_config_error = GRPC_ERROR_NONE;
-    RefCountedPtr<ServiceConfig> service_config =
-        ServiceConfig::Create(service_config_json, &service_config_error);
-    // service_config_error is currently unused.
-    GRPC_ERROR_UNREF(service_config_error);
-    if (service_config != nullptr) {
-      HealthCheckParams params;
-      service_config->ParseGlobalParams(HealthCheckParams::Parse, &params);
-      health_check_service_name_ = std::move(params.service_name);
-    }
+
+  if (health_check != nullptr) {
+    health_check_service_name_ =
+        UniquePtr<char>(gpr_strdup(health_check->service_name()));
   }
   const grpc_arg* arg = grpc_channel_args_find(args_, GRPC_ARG_ENABLE_CHANNELZ);
   const bool channelz_enabled =
@@ -635,7 +607,8 @@ Subchannel::~Subchannel() {
 }
 
 Subchannel* Subchannel::Create(grpc_connector* connector,
-                               const grpc_channel_args* args) {
+                               const grpc_channel_args* args,
+                               const HealthCheckParsedObject* health_check) {
   SubchannelKey* key = New<SubchannelKey>(args);
   SubchannelPoolInterface* subchannel_pool =
       SubchannelPoolInterface::GetSubchannelPoolFromChannelArgs(args);
@@ -645,7 +618,7 @@ Subchannel* Subchannel::Create(grpc_connector* connector,
     Delete(key);
     return c;
   }
-  c = New<Subchannel>(key, connector, args);
+  c = New<Subchannel>(key, connector, args, health_check);
   // 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

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

@@ -23,6 +23,7 @@
 
 #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/health/health_check_parser.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"
@@ -178,12 +179,14 @@ class Subchannel {
  public:
   // The ctor and dtor are not intended to use directly.
   Subchannel(SubchannelKey* key, grpc_connector* connector,
-             const grpc_channel_args* args);
+             const grpc_channel_args* args,
+             const HealthCheckParsedObject* health_check);
   ~Subchannel();
 
   // Creates a subchannel given \a connector and \a args.
   static Subchannel* Create(grpc_connector* connector,
-                            const grpc_channel_args* args);
+                            const grpc_channel_args* args,
+                            const HealthCheckParsedObject* health_check);
 
   // Strong and weak refcounting.
   Subchannel* Ref(GRPC_SUBCHANNEL_REF_EXTRA_ARGS);

src/core/ext/filters/message_size/message_size_filter.cc

@@ -127,7 +127,6 @@ UniquePtr<ServiceConfigParsedObject> MessageSizeParser::ParsePerMethodParams(
 }
 
 void MessageSizeParser::Register() {
-  gpr_log(GPR_ERROR, "registered");
   message_size_parser_index = ServiceConfig::RegisterParser(
       UniquePtr<ServiceConfigParser>(New<MessageSizeParser>()));
 }

src/core/ext/transport/chttp2/client/insecure/channel_create.cc

@@ -37,11 +37,13 @@ namespace grpc_core {
 
 class Chttp2InsecureClientChannelFactory : public ClientChannelFactory {
  public:
-  Subchannel* CreateSubchannel(const grpc_channel_args* args) override {
+  Subchannel* CreateSubchannel(
+      const grpc_channel_args* args,
+      const HealthCheckParsedObject* health_check) override {
     grpc_channel_args* new_args =
         grpc_default_authority_add_if_not_present(args);
     grpc_connector* connector = grpc_chttp2_connector_create();
-    Subchannel* s = Subchannel::Create(connector, new_args);
+    Subchannel* s = Subchannel::Create(connector, new_args, health_check);
     grpc_connector_unref(connector);
     grpc_channel_args_destroy(new_args);
     return s;

src/core/ext/transport/chttp2/client/secure/secure_channel_create.cc

@@ -44,7 +44,9 @@ namespace grpc_core {
 
 class Chttp2SecureClientChannelFactory : public ClientChannelFactory {
  public:
-  Subchannel* CreateSubchannel(const grpc_channel_args* args) override {
+  Subchannel* CreateSubchannel(
+      const grpc_channel_args* args,
+      const HealthCheckParsedObject* health_check) override {
     grpc_channel_args* new_args = GetSecureNamingChannelArgs(args);
     if (new_args == nullptr) {
       gpr_log(GPR_ERROR,
@@ -52,7 +54,7 @@ class Chttp2SecureClientChannelFactory : public ClientChannelFactory {
       return nullptr;
     }
     grpc_connector* connector = grpc_chttp2_connector_create();
-    Subchannel* s = Subchannel::Create(connector, new_args);
+    Subchannel* s = Subchannel::Create(connector, new_args, health_check);
     grpc_connector_unref(connector);
     grpc_channel_args_destroy(new_args);
     return s;

test/core/util/test_lb_policies.cc

@@ -141,8 +141,11 @@ class InterceptRecvTrailingMetadataLoadBalancingPolicy
         InterceptRecvTrailingMetadataCallback cb, void* user_data)
         : parent_(std::move(parent)), cb_(cb), user_data_(user_data) {}
 
-    Subchannel* CreateSubchannel(const grpc_channel_args& args) override {
-      return parent_->channel_control_helper()->CreateSubchannel(args);
+    Subchannel* CreateSubchannel(
+        const grpc_channel_args& args,
+        const HealthCheckParsedObject* health_check) override {
+      return parent_->channel_control_helper()->CreateSubchannel(args,
+                                                                 health_check);
     }
 
     grpc_channel* CreateChannel(const char* target,

test/cpp/microbenchmarks/bm_call_create.cc

@@ -30,6 +30,7 @@
 #include <grpcpp/support/channel_arguments.h>
 
 #include "src/core/ext/filters/client_channel/client_channel.h"
+#include "src/core/ext/filters/client_channel/client_channel_factory.h"
 #include "src/core/ext/filters/deadline/deadline_filter.h"
 #include "src/core/ext/filters/http/client/http_client_filter.h"
 #include "src/core/ext/filters/http/message_compress/message_compress_filter.h"
@@ -321,7 +322,8 @@ static void DoNothing(void* arg, grpc_error* error) {}
 class FakeClientChannelFactory : public grpc_core::ClientChannelFactory {
  public:
   grpc_core::Subchannel* CreateSubchannel(
-      const grpc_channel_args* args) override {
+      const grpc_channel_args* args,
+      const grpc_core::HealthCheckParsedObject* health_check) override {
     return nullptr;
   }
   grpc_channel* CreateChannel(const char* target,