grpc 1.49.1-x86_64-linux → 1.50.0-x86_64-linux

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

@@ -47,6 +47,7 @@
 #include "src/core/ext/filters/client_channel/lb_policy/xds/xds_channel_args.h"
 #include "src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h"
 #include "src/core/ext/xds/xds_bootstrap.h"
+#include "src/core/ext/xds/xds_bootstrap_grpc.h"
 #include "src/core/ext/xds/xds_client.h"
 #include "src/core/ext/xds/xds_client_grpc.h"
 #include "src/core/ext/xds/xds_client_stats.h"
@@ -55,14 +56,15 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/gprpp/work_serializer.h"
-#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/json/json.h"
+#include "src/core/lib/json/json_args.h"
+#include "src/core/lib/json/json_object_loader.h"
 #include "src/core/lib/load_balancing/lb_policy.h"
 #include "src/core/lib/load_balancing/lb_policy_factory.h"
 #include "src/core/lib/load_balancing/lb_policy_registry.h"
@@ -71,7 +73,6 @@
 #include "src/core/lib/resolver/resolver_registry.h"
 #include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/transport/connectivity_state.h"
-#include "src/core/lib/transport/error_utils.h"
 
 #define GRPC_EDS_DEFAULT_FALLBACK_TIMEOUT 10000
 
@@ -91,7 +92,7 @@ class XdsClusterResolverLbConfig : public LoadBalancingPolicy::Config {
  public:
   struct DiscoveryMechanism {
     std::string cluster_name;
-    absl::optional<XdsBootstrap::XdsServer> lrs_load_reporting_server;
+    absl::optional<GrpcXdsBootstrap::GrpcXdsServer> lrs_load_reporting_server;
     uint32_t max_concurrent_requests;
     enum DiscoveryMechanismType {
       EDS,
@@ -100,6 +101,13 @@ class XdsClusterResolverLbConfig : public LoadBalancingPolicy::Config {
     DiscoveryMechanismType type;
     std::string eds_service_name;
     std::string dns_hostname;
+
+    // This is type Json::Object instead of OutlierDetectionConfig, because we
+    // don't actually need to validate the contents of the outlier detection
+    // config here.  In this case, the JSON is generated by the CDS policy
+    // instead of coming from service config, so it's not actually any better
+    // to catch the problem here than it is to catch it in the
+    // outlier_detection policy itself, so here we just act as a pass-through.
     absl::optional<Json::Object> outlier_detection_lb_config;
 
     bool operator==(const DiscoveryMechanism& other) const {
@@ -111,12 +119,21 @@ class XdsClusterResolverLbConfig : public LoadBalancingPolicy::Config {
               dns_hostname == other.dns_hostname &&
               outlier_detection_lb_config == other.outlier_detection_lb_config);
     }
+
+    static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+    void JsonPostLoad(const Json& json, const JsonArgs& args,
+                      ValidationErrors* errors);
   };
 
-  XdsClusterResolverLbConfig(
-      std::vector<DiscoveryMechanism> discovery_mechanisms, Json xds_lb_policy)
-      : discovery_mechanisms_(std::move(discovery_mechanisms)),
-        xds_lb_policy_(std::move(xds_lb_policy)) {}
+  XdsClusterResolverLbConfig() = default;
+
+  XdsClusterResolverLbConfig(const XdsClusterResolverLbConfig&) = delete;
+  XdsClusterResolverLbConfig& operator=(const XdsClusterResolverLbConfig&) =
+      delete;
+
+  XdsClusterResolverLbConfig(XdsClusterResolverLbConfig&& other) = delete;
+  XdsClusterResolverLbConfig& operator=(XdsClusterResolverLbConfig&& other) =
+      delete;
 
   absl::string_view name() const override { return kXdsClusterResolver; }
 
@@ -126,9 +143,13 @@ class XdsClusterResolverLbConfig : public LoadBalancingPolicy::Config {
 
   const Json& xds_lb_policy() const { return xds_lb_policy_; }
 
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+  void JsonPostLoad(const Json& json, const JsonArgs& args,
+                    ValidationErrors* errors);
+
  private:
   std::vector<DiscoveryMechanism> discovery_mechanisms_;
-  Json xds_lb_policy_;
+  Json xds_lb_policy_ = Json::Object{{"ROUND_ROBIN", Json::Object()}};
 };
 
 // Xds Cluster Resolver LB policy.
@@ -138,7 +159,7 @@ class XdsClusterResolverLb : public LoadBalancingPolicy {
 
   absl::string_view name() const override { return kXdsClusterResolver; }
 
-  void UpdateLocked(UpdateArgs args) override;
+  absl::Status UpdateLocked(UpdateArgs args) override;
   void ResetBackoffLocked() override;
   void ExitIdleLocked() override;
 
@@ -380,7 +401,7 @@ class XdsClusterResolverLb : public LoadBalancingPolicy {
 
   void MaybeDestroyChildPolicyLocked();
 
-  void UpdateChildPolicyLocked();
+  absl::Status UpdateChildPolicyLocked();
   OrphanablePtr<LoadBalancingPolicy> CreateChildPolicyLocked(
       const ChannelArgs& args);
   ServerAddressList CreateChildPolicyAddressesLocked();
@@ -610,7 +631,7 @@ void XdsClusterResolverLb::MaybeDestroyChildPolicyLocked() {
   }
 }
 
-void XdsClusterResolverLb::UpdateLocked(UpdateArgs args) {
+absl::Status XdsClusterResolverLb::UpdateLocked(UpdateArgs args) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_cluster_resolver_trace)) {
     gpr_log(GPR_INFO, "[xds_cluster_resolver_lb %p] Received update", this);
   }
@@ -621,7 +642,8 @@ void XdsClusterResolverLb::UpdateLocked(UpdateArgs args) {
   // Update args.
   args_ = std::move(args.args);
   // Update child policy if needed.
-  if (child_policy_ != nullptr) UpdateChildPolicyLocked();
+  absl::Status status;
+  if (child_policy_ != nullptr) status = UpdateChildPolicyLocked();
   // Create endpoint watcher if needed.
   if (is_initial_update) {
     for (const auto& config : config_->discovery_mechanisms()) {
@@ -647,6 +669,7 @@ void XdsClusterResolverLb::UpdateLocked(UpdateArgs args) {
       discovery_mechanism.discovery_mechanism->Start();
     }
   }
+  return status;
 }
 
 void XdsClusterResolverLb::ResetBackoffLocked() {
@@ -755,7 +778,9 @@ void XdsClusterResolverLb::OnEndpointChanged(size_t index,
     if (!mechanism.latest_update.has_value()) return;
   }
   // Update child policy.
-  UpdateChildPolicyLocked();
+  // TODO(roth): If the child policy reports an error with the update,
+  // we need to propagate that error back to the resolver somehow.
+  (void)UpdateChildPolicyLocked();
 }
 
 void XdsClusterResolverLb::OnError(size_t index, std::string resolution_note) {
@@ -974,7 +999,9 @@ XdsClusterResolverLb::CreateChildPolicyConfigLocked() {
         "[xds_cluster_resolver_lb %p] generated config for child policy: %s",
         this, json_str.c_str());
   }
-  auto config = LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(json);
+  auto config =
+      CoreConfiguration::Get().lb_policy_registry().ParseLoadBalancingConfig(
+          json);
   if (!config.ok()) {
     // This should never happen, but if it does, we basically have no
     // way to fix it, so we put the channel in TRANSIENT_FAILURE.
@@ -994,11 +1021,11 @@ XdsClusterResolverLb::CreateChildPolicyConfigLocked() {
   return std::move(*config);
 }
 
-void XdsClusterResolverLb::UpdateChildPolicyLocked() {
-  if (shutting_down_) return;
+absl::Status XdsClusterResolverLb::UpdateChildPolicyLocked() {
+  if (shutting_down_) return absl::OkStatus();
   UpdateArgs update_args;
   update_args.config = CreateChildPolicyConfigLocked();
-  if (update_args.config == nullptr) return;
+  if (update_args.config == nullptr) return absl::OkStatus();
   update_args.addresses = CreateChildPolicyAddressesLocked();
   update_args.resolution_note = CreateChildPolicyResolutionNoteLocked();
   update_args.args = CreateChildPolicyArgsLocked(args_);
@@ -1009,7 +1036,7 @@ void XdsClusterResolverLb::UpdateChildPolicyLocked() {
     gpr_log(GPR_INFO, "[xds_cluster_resolver_lb %p] Updating child policy %p",
             this, child_policy_.get());
   }
-  child_policy_->UpdateLocked(std::move(update_args));
+  return child_policy_->UpdateLocked(std::move(update_args));
 }
 
 ChannelArgs XdsClusterResolverLb::CreateChildPolicyArgsLocked(
@@ -1027,7 +1054,7 @@ XdsClusterResolverLb::CreateChildPolicyLocked(const ChannelArgs& args) {
   lb_policy_args.channel_control_helper =
       absl::make_unique<Helper>(Ref(DEBUG_LOCATION, "Helper"));
   OrphanablePtr<LoadBalancingPolicy> lb_policy =
-      LoadBalancingPolicyRegistry::CreateLoadBalancingPolicy(
+      CoreConfiguration::Get().lb_policy_registry().CreateLoadBalancingPolicy(
           "priority_experimental", std::move(lb_policy_args));
   if (GPR_UNLIKELY(lb_policy == nullptr)) {
     gpr_log(GPR_ERROR,
@@ -1051,6 +1078,117 @@ XdsClusterResolverLb::CreateChildPolicyLocked(const ChannelArgs& args) {
 // factory
 //
 
+const JsonLoaderInterface*
+XdsClusterResolverLbConfig::DiscoveryMechanism::JsonLoader(const JsonArgs&) {
+  static const auto* loader =
+      JsonObjectLoader<DiscoveryMechanism>()
+          // Note: Several fields requires custom processing,
+          // so they are handled in JsonPostLoad() instead.
+          .Field("clusterName", &DiscoveryMechanism::cluster_name)
+          .OptionalField("lrsLoadReportingServer",
+                         &DiscoveryMechanism::lrs_load_reporting_server)
+          .OptionalField("max_concurrent_requests",
+                         &DiscoveryMechanism::max_concurrent_requests)
+          .OptionalField("outlierDetection",
+                         &DiscoveryMechanism::outlier_detection_lb_config,
+                         "outlier_detection")
+          .Finish();
+  return loader;
+}
+
+void XdsClusterResolverLbConfig::DiscoveryMechanism::JsonPostLoad(
+    const Json& json, const JsonArgs& args, ValidationErrors* errors) {
+  // Parse "type".
+  {
+    auto type_field = LoadJsonObjectField<std::string>(json.object_value(),
+                                                       args, "type", errors);
+    if (type_field.has_value()) {
+      if (*type_field == "EDS") {
+        type = DiscoveryMechanismType::EDS;
+      } else if (*type_field == "LOGICAL_DNS") {
+        type = DiscoveryMechanismType::LOGICAL_DNS;
+      } else {
+        ValidationErrors::ScopedField field(errors, ".type");
+        errors->AddError(absl::StrCat("unknown type \"", *type_field, "\""));
+      }
+    }
+  }
+  // Parse "edsServiceName" if type is EDS.
+  if (type == DiscoveryMechanismType::EDS) {
+    auto value = LoadJsonObjectField<std::string>(json.object_value(), args,
+                                                  "edsServiceName", errors,
+                                                  /*required=*/false);
+    if (value.has_value()) eds_service_name = std::move(*value);
+  }
+  // Parse "dnsHostname" if type is LOGICAL_DNS.
+  if (type == DiscoveryMechanismType::LOGICAL_DNS) {
+    auto value = LoadJsonObjectField<std::string>(json.object_value(), args,
+                                                  "dnsHostname", errors);
+    if (value.has_value()) dns_hostname = std::move(*value);
+  }
+}
+
+const JsonLoaderInterface* XdsClusterResolverLbConfig::JsonLoader(
+    const JsonArgs&) {
+  static const auto* loader =
+      JsonObjectLoader<XdsClusterResolverLbConfig>()
+          // Note: The "xdsLbPolicy" field requires custom processing,
+          // so it's handled in JsonPostLoad() instead.
+          .Field("discoveryMechanisms",
+                 &XdsClusterResolverLbConfig::discovery_mechanisms_)
+          .Finish();
+  return loader;
+}
+
+void XdsClusterResolverLbConfig::JsonPostLoad(const Json& json,
+                                              const JsonArgs& args,
+                                              ValidationErrors* errors) {
+  // Validate discoveryMechanisms.
+  {
+    ValidationErrors::ScopedField field(errors, ".discoveryMechanisms");
+    if (!errors->FieldHasErrors() && discovery_mechanisms_.empty()) {
+      errors->AddError("must be non-empty");
+    }
+  }
+  // Parse "xdsLbPolicy".
+  {
+    ValidationErrors::ScopedField field(errors, ".xdsLbPolicy");
+    auto it = json.object_value().find("xdsLbPolicy");
+    if (it != json.object_value().end()) {
+      if (it->second.type() != Json::Type::ARRAY) {
+        errors->AddError("is not an array");
+      } else {
+        const Json::Array& array = it->second.array_value();
+        for (size_t i = 0; i < array.size(); ++i) {
+          ValidationErrors::ScopedField field(errors,
+                                              absl::StrCat("[", i, "]"));
+          if (array[i].type() != Json::Type::OBJECT) {
+            errors->AddError("is not an object");
+            continue;
+          }
+          const Json::Object& policy = array[i].object_value();
+          auto policy_it = policy.find("ROUND_ROBIN");
+          if (policy_it != policy.end()) {
+            ValidationErrors::ScopedField field(errors, "[\"ROUND_ROBIN\"]");
+            if (policy_it->second.type() != Json::Type::OBJECT) {
+              errors->AddError("is not an object");
+            }
+            break;
+          }
+          {
+            ValidationErrors::ScopedField field(errors, "[\"RING_HASH\"]");
+            policy_it = policy.find("RING_HASH");
+            if (policy_it != policy.end()) {
+              LoadFromJson<RingHashConfig>(policy_it->second, args, errors);
+              xds_lb_policy_ = array[i];
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
 class XdsClusterResolverLbFactory : public LoadBalancingPolicyFactory {
  public:
   OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
@@ -1079,198 +1217,19 @@ class XdsClusterResolverLbFactory : public LoadBalancingPolicyFactory {
           "requires configuration. "
           "Please use loadBalancingConfig field of service config instead.");
     }
-    std::vector<grpc_error_handle> error_list;
-    std::vector<XdsClusterResolverLbConfig::DiscoveryMechanism>
-        discovery_mechanisms;
-    auto it = json.object_value().find("discoveryMechanisms");
-    if (it == json.object_value().end()) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:discoveryMechanisms error:required field missing"));
-    } else if (it->second.type() != Json::Type::ARRAY) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:discoveryMechanisms error:type should be array"));
-    } else {
-      const Json::Array& array = it->second.array_value();
-      for (size_t i = 0; i < array.size(); ++i) {
-        XdsClusterResolverLbConfig::DiscoveryMechanism discovery_mechanism;
-        std::vector<grpc_error_handle> discovery_mechanism_errors =
-            ParseDiscoveryMechanism(array[i], &discovery_mechanism);
-        if (!discovery_mechanism_errors.empty()) {
-          grpc_error_handle error = GRPC_ERROR_CREATE_FROM_CPP_STRING(
-              absl::StrCat("field:discovery_mechanism element: ", i, " error"));
-          for (const grpc_error_handle& discovery_mechanism_error :
-               discovery_mechanism_errors) {
-            error = grpc_error_add_child(error, discovery_mechanism_error);
-          }
-          error_list.push_back(error);
-        }
-        discovery_mechanisms.emplace_back(std::move(discovery_mechanism));
+    class XdsJsonArgs : public JsonArgs {
+     public:
+      bool IsEnabled(absl::string_view key) const override {
+        if (key == "outlier_detection") return XdsOutlierDetectionEnabled();
+        return true;
       }
-    }
-    if (discovery_mechanisms.empty()) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:discovery_mechanism error:list is missing or empty"));
-    }
-    Json xds_lb_policy = Json::Object{
-        {"ROUND_ROBIN", Json::Object()},
     };
-    it = json.object_value().find("xdsLbPolicy");
-    if (it != json.object_value().end()) {
-      if (it->second.type() != Json::Type::ARRAY) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:xdsLbPolicy error:type should be array"));
-      } else {
-        const Json::Array& array = it->second.array_value();
-        for (size_t i = 0; i < array.size(); ++i) {
-          if (array[i].type() != Json::Type::OBJECT) {
-            error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                "field:xdsLbPolicy error:element should be of type object"));
-            continue;
-          }
-          const Json::Object& policy = array[i].object_value();
-          auto policy_it = policy.find("ROUND_ROBIN");
-          if (policy_it != policy.end()) {
-            if (policy_it->second.type() != Json::Type::OBJECT) {
-              error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                  "field:ROUND_ROBIN error:type should be object"));
-            }
-            break;
-          }
-          policy_it = policy.find("RING_HASH");
-          if (policy_it != policy.end()) {
-            xds_lb_policy = array[i];
-            auto config = ParseRingHashLbConfig(policy_it->second);
-            if (!config.ok()) {
-              error_list.emplace_back(
-                  absl_status_to_grpc_error(config.status()));
-            }
-          }
-        }
-      }
-    }
-    // Construct config.
-    if (error_list.empty()) {
-      return MakeRefCounted<XdsClusterResolverLbConfig>(
-          std::move(discovery_mechanisms), std::move(xds_lb_policy));
-    } else {
-      grpc_error_handle error = GRPC_ERROR_CREATE_FROM_VECTOR(
-          "xds_cluster_resolver_experimental LB policy config", &error_list);
-      absl::Status status = grpc_error_to_absl_status(error);
-      GRPC_ERROR_UNREF(error);
-      return status;
-    }
+    return LoadRefCountedFromJson<XdsClusterResolverLbConfig>(
+        json, XdsJsonArgs(),
+        "errors validating xds_cluster_resolver LB policy config");
   }
 
  private:
-  static std::vector<grpc_error_handle> ParseDiscoveryMechanism(
-      const Json& json,
-      XdsClusterResolverLbConfig::DiscoveryMechanism* discovery_mechanism) {
-    std::vector<grpc_error_handle> error_list;
-    if (json.type() != Json::Type::OBJECT) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "value should be of type object"));
-      return error_list;
-    }
-    // Cluster name.
-    auto it = json.object_value().find("clusterName");
-    if (it == json.object_value().end()) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:clusterName error:required field missing"));
-    } else if (it->second.type() != Json::Type::STRING) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:clusterName error:type should be string"));
-    } else {
-      discovery_mechanism->cluster_name = it->second.string_value();
-    }
-    // LRS load reporting server name.
-    it = json.object_value().find("lrsLoadReportingServer");
-    if (it != json.object_value().end()) {
-      if (it->second.type() != Json::Type::OBJECT) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:lrsLoadReportingServer error:type should be object"));
-      } else {
-        grpc_error_handle parse_error;
-        discovery_mechanism->lrs_load_reporting_server.emplace(
-            XdsBootstrap::XdsServer::Parse(it->second, &parse_error));
-        if (!GRPC_ERROR_IS_NONE(parse_error)) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
-              absl::StrCat("errors parsing lrs_load_reporting_server")));
-          error_list.push_back(parse_error);
-        }
-      }
-    }
-    // Max concurrent requests.
-    discovery_mechanism->max_concurrent_requests = 1024;
-    it = json.object_value().find("max_concurrent_requests");
-    if (it != json.object_value().end()) {
-      if (it->second.type() != Json::Type::NUMBER) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:max_concurrent_requests error:must be of type number"));
-      } else {
-        discovery_mechanism->max_concurrent_requests =
-            gpr_parse_nonnegative_int(it->second.string_value().c_str());
-      }
-    }
-    if (XdsOutlierDetectionEnabled()) {
-      it = json.object_value().find("outlierDetection");
-      if (it != json.object_value().end()) {
-        if (it->second.type() != Json::Type::OBJECT) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "field:outlierDetection error:type should be object"));
-        } else {
-          // No need to validate the contents of the outlier detection config,
-          // because in this particular case, the JSON is generated by the CDS
-          // policy instead of coming from service config, so it's not actually
-          // any better to catch the problem here than it is to catch it in the
-          // outlier_detection policy itself, so here we just act as a
-          // pass-through.
-          discovery_mechanism->outlier_detection_lb_config =
-              it->second.object_value();
-        }
-      }
-    }
-    // Discovery Mechanism type
-    it = json.object_value().find("type");
-    if (it == json.object_value().end()) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:type error:required field missing"));
-    } else if (it->second.type() != Json::Type::STRING) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:type error:type should be string"));
-    } else {
-      if (it->second.string_value() == "EDS") {
-        discovery_mechanism->type = XdsClusterResolverLbConfig::
-            DiscoveryMechanism::DiscoveryMechanismType::EDS;
-        it = json.object_value().find("edsServiceName");
-        if (it != json.object_value().end()) {
-          if (it->second.type() != Json::Type::STRING) {
-            error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                "field:edsServiceName error:type should be string"));
-          } else {
-            discovery_mechanism->eds_service_name = it->second.string_value();
-          }
-        }
-      } else if (it->second.string_value() == "LOGICAL_DNS") {
-        discovery_mechanism->type = XdsClusterResolverLbConfig::
-            DiscoveryMechanism::DiscoveryMechanismType::LOGICAL_DNS;
-        it = json.object_value().find("dnsHostname");
-        if (it == json.object_value().end()) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "field:dnsHostname error:required field missing"));
-        } else if (it->second.type() != Json::Type::STRING) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "field:dnsHostname error:type should be string"));
-        } else {
-          discovery_mechanism->dns_hostname = it->second.string_value();
-        }
-      } else {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:type error:invalid type"));
-      }
-    }
-    return error_list;
-  }
-
   class XdsClusterResolverChildHandler : public ChildPolicyHandler {
    public:
     XdsClusterResolverChildHandler(RefCountedPtr<XdsClient> xds_client,
@@ -1333,16 +1292,9 @@ class XdsClusterResolverLbFactory : public LoadBalancingPolicyFactory {
 
 }  // namespace
 
-}  // namespace grpc_core
-
-//
-// Plugin registration
-//
-
-void grpc_lb_policy_xds_cluster_resolver_init() {
-  grpc_core::LoadBalancingPolicyRegistry::Builder::
-      RegisterLoadBalancingPolicyFactory(
-          absl::make_unique<grpc_core::XdsClusterResolverLbFactory>());
+void RegisterXdsClusterResolverLbPolicy(CoreConfiguration::Builder* builder) {
+  builder->lb_policy_registry()->RegisterLoadBalancingPolicyFactory(
+      absl::make_unique<XdsClusterResolverLbFactory>());
 }
 
-void grpc_lb_policy_xds_cluster_resolver_shutdown() {}
+}  // namespace grpc_core

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.cc

@@ -284,7 +284,7 @@ static grpc_core::Timestamp calculate_next_ares_backup_poll_alarm(
       "request:%p ev_driver=%p. next ares process poll time in "
       "%" PRId64 " ms",
       driver->request, driver, until_next_ares_backup_poll_alarm.millis());
-  return grpc_core::ExecCtx::Get()->Now() + until_next_ares_backup_poll_alarm;
+  return grpc_core::Timestamp::Now() + until_next_ares_backup_poll_alarm;
 }
 
 static void on_timeout(void* arg, grpc_error_handle error) {
@@ -496,7 +496,7 @@ void grpc_ares_ev_driver_start_locked(grpc_ares_ev_driver* ev_driver)
   GRPC_CLOSURE_INIT(&ev_driver->on_timeout_locked, on_timeout, ev_driver,
                     grpc_schedule_on_exec_ctx);
   grpc_timer_init(&ev_driver->query_timeout,
-                  grpc_core::ExecCtx::Get()->Now() + timeout,
+                  grpc_core::Timestamp::Now() + timeout,
                   &ev_driver->on_timeout_locked);
   // Initialize the backup poll alarm
   grpc_core::Timestamp next_ares_backup_poll_alarm =

data/src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.cc

@@ -82,7 +82,7 @@ class NativeClientChannelDNSResolver : public PollingResolver {
    public:
     Request() = default;
 
-    void Orphan() override {}
+    void Orphan() override { delete this; }
   };
 
   void OnResolved(

data/src/core/ext/filters/client_channel/resolver/google_c2p/google_c2p_resolver.cc

@@ -42,9 +42,8 @@
 #include "src/core/ext/xds/xds_client_grpc.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/gpr/env.h"
 #include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/env.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"
@@ -53,7 +52,6 @@
 #include "src/core/lib/http/parser.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/resolver/resolver.h"
@@ -168,12 +166,12 @@ GoogleCloud2ProdResolver::MetadataQuery::MetadataQuery(
       const_cast<char*>(GRPC_ARG_RESOURCE_QUOTA),
       resolver_->resource_quota_.get(), grpc_resource_quota_arg_vtable());
   grpc_channel_args args = {1, &resource_quota_arg};
-  http_request_ = HttpRequest::Get(
-      std::move(*uri), &args, pollent, &request,
-      ExecCtx::Get()->Now() + Duration::Seconds(10),  // 10s timeout
-      &on_done_, &response_,
-      RefCountedPtr<grpc_channel_credentials>(
-          grpc_insecure_credentials_create()));
+  http_request_ =
+      HttpRequest::Get(std::move(*uri), &args, pollent, &request,
+                       Timestamp::Now() + Duration::Seconds(10),  // 10s timeout
+                       &on_done_, &response_,
+                       RefCountedPtr<grpc_channel_credentials>(
+                           grpc_insecure_credentials_create()));
   http_request_->Start();
 }
 
@@ -285,8 +283,8 @@ GoogleCloud2ProdResolver::GoogleCloud2ProdResolver(ResolverArgs args)
       // they may be talking to a completely different xDS server than we
       // want to.
       // TODO(roth): When we implement xDS federation, remove this constraint.
-      UniquePtr<char>(gpr_getenv("GRPC_XDS_BOOTSTRAP")) != nullptr ||
-      UniquePtr<char>(gpr_getenv("GRPC_XDS_BOOTSTRAP_CONFIG")) != nullptr) {
+      GetEnv("GRPC_XDS_BOOTSTRAP").has_value() ||
+      GetEnv("GRPC_XDS_BOOTSTRAP_CONFIG").has_value()) {
     using_dns_ = true;
     child_resolver_ =
         CoreConfiguration::Get().resolver_registry().CreateResolver(
@@ -373,11 +371,11 @@ void GoogleCloud2ProdResolver::StartXdsResolver() {
     };
   }
   // Allow the TD server uri to be overridden for testing purposes.
-  UniquePtr<char> override_server(
-      gpr_getenv("GRPC_TEST_ONLY_GOOGLE_C2P_RESOLVER_TRAFFIC_DIRECTOR_URI"));
+  auto override_server =
+      GetEnv("GRPC_TEST_ONLY_GOOGLE_C2P_RESOLVER_TRAFFIC_DIRECTOR_URI");
   const char* server_uri =
-      override_server != nullptr && strlen(override_server.get()) > 0
-          ? override_server.get()
+      override_server.has_value() && !override_server->empty()
+          ? override_server->c_str()
           : "directpath-pa.googleapis.com";
   Json xds_server = Json::Array{
       Json::Object{