grpc 1.56.2 → 1.57.0.pre1

data/src/core/ext/upbdefs-generated/envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.upbdefs.h

@@ -57,6 +57,11 @@ UPB_INLINE const upb_MessageDef *envoy_extensions_filters_network_http_connectio
   return upb_DefPool_FindMessageByName(s, "envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.ProxyStatusConfig");
 }
 
+UPB_INLINE const upb_MessageDef *envoy_extensions_filters_network_http_connection_manager_v3_HttpConnectionManager_HcmAccessLogOptions_getmsgdef(upb_DefPool *s) {
+  _upb_DefPool_LoadDefInit(s, &envoy_extensions_filters_network_http_connection_manager_v3_http_connection_manager_proto_upbdefinit);
+  return upb_DefPool_FindMessageByName(s, "envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.HcmAccessLogOptions");
+}
+
 UPB_INLINE const upb_MessageDef *envoy_extensions_filters_network_http_connection_manager_v3_LocalReplyConfig_getmsgdef(upb_DefPool *s) {
   _upb_DefPool_LoadDefInit(s, &envoy_extensions_filters_network_http_connection_manager_v3_http_connection_manager_proto_upbdefinit);
   return upb_DefPool_FindMessageByName(s, "envoy.extensions.filters.network.http_connection_manager.v3.LocalReplyConfig");

data/src/core/ext/upbdefs-generated/envoy/type/matcher/v3/regex.upbdefs.c

@@ -15,7 +15,7 @@ extern _upb_DefPool_Init envoy_annotations_deprecation_proto_upbdefinit;
 extern _upb_DefPool_Init udpa_annotations_status_proto_upbdefinit;
 extern _upb_DefPool_Init udpa_annotations_versioning_proto_upbdefinit;
 extern _upb_DefPool_Init validate_validate_proto_upbdefinit;
-static const char descriptor[914] = {'\n', '!', 'e', 'n', 'v', 'o', 'y', '/', 't', 'y', 'p', 'e', '/', 'm', 'a', 't', 'c', 'h', 'e', 'r', '/', 'v', '3', '/', 'r', 
+static const char descriptor[906] = {'\n', '!', 'e', 'n', 'v', 'o', 'y', '/', 't', 'y', 'p', 'e', '/', 'm', 'a', 't', 'c', 'h', 'e', 'r', '/', 'v', '3', '/', 'r', 
 'e', 'g', 'e', 'x', '.', 'p', 'r', 'o', 't', 'o', '\022', '\025', 'e', 'n', 'v', 'o', 'y', '.', 't', 'y', 'p', 'e', '.', 'm', 'a', 
 't', 'c', 'h', 'e', 'r', '.', 'v', '3', '\032', '\036', 'g', 'o', 'o', 'g', 'l', 'e', '/', 'p', 'r', 'o', 't', 'o', 'b', 'u', 'f', 
 '/', 'w', 'r', 'a', 'p', 'p', 'e', 'r', 's', '.', 'p', 'r', 'o', 't', 'o', '\032', '#', 'e', 'n', 'v', 'o', 'y', '/', 'a', 'n', 
@@ -23,35 +23,35 @@ static const char descriptor[914] = {'\n', '!', 'e', 'n', 'v', 'o', 'y', '/', 't
 't', 'o', '\032', '\035', 'u', 'd', 'p', 'a', '/', 'a', 'n', 'n', 'o', 't', 'a', 't', 'i', 'o', 'n', 's', '/', 's', 't', 'a', 't', 
 'u', 's', '.', 'p', 'r', 'o', 't', 'o', '\032', '!', 'u', 'd', 'p', 'a', '/', 'a', 'n', 'n', 'o', 't', 'a', 't', 'i', 'o', 'n', 
 's', '/', 'v', 'e', 'r', 's', 'i', 'o', 'n', 'i', 'n', 'g', '.', 'p', 'r', 'o', 't', 'o', '\032', '\027', 'v', 'a', 'l', 'i', 'd', 
-'a', 't', 'e', '/', 'v', 'a', 'l', 'i', 'd', 'a', 't', 'e', '.', 'p', 'r', 'o', 't', 'o', '\"', '\336', '\002', '\n', '\014', 'R', 'e', 
-'g', 'e', 'x', 'M', 'a', 't', 'c', 'h', 'e', 'r', '\022', 'c', '\n', '\n', 'g', 'o', 'o', 'g', 'l', 'e', '_', 'r', 'e', '2', '\030', 
+'a', 't', 'e', '/', 'v', 'a', 'l', 'i', 'd', 'a', 't', 'e', '.', 'p', 'r', 'o', 't', 'o', '\"', '\326', '\002', '\n', '\014', 'R', 'e', 
+'g', 'e', 'x', 'M', 'a', 't', 'c', 'h', 'e', 'r', '\022', '[', '\n', '\n', 'g', 'o', 'o', 'g', 'l', 'e', '_', 'r', 'e', '2', '\030', 
 '\001', ' ', '\001', '(', '\013', '2', '-', '.', 'e', 'n', 'v', 'o', 'y', '.', 't', 'y', 'p', 'e', '.', 'm', 'a', 't', 'c', 'h', 'e', 
 'r', '.', 'v', '3', '.', 'R', 'e', 'g', 'e', 'x', 'M', 'a', 't', 'c', 'h', 'e', 'r', '.', 'G', 'o', 'o', 'g', 'l', 'e', 'R', 
-'E', '2', 'B', '\023', '\030', '\001', '\372', 'B', '\005', '\212', '\001', '\002', '\020', '\001', '\222', '\307', '\206', '\330', '\004', '\003', '3', '.', '0', 'H', '\000', 
-'R', '\t', 'g', 'o', 'o', 'g', 'l', 'e', 'R', 'e', '2', '\022', '\035', '\n', '\005', 'r', 'e', 'g', 'e', 'x', '\030', '\002', ' ', '\001', '(', 
-'\t', 'B', '\007', '\372', 'B', '\004', 'r', '\002', '\020', '\001', 'R', '\005', 'r', 'e', 'g', 'e', 'x', '\032', '\222', '\001', '\n', '\t', 'G', 'o', 'o', 
-'g', 'l', 'e', 'R', 'E', '2', '\022', 'S', '\n', '\020', 'm', 'a', 'x', '_', 'p', 'r', 'o', 'g', 'r', 'a', 'm', '_', 's', 'i', 'z', 
-'e', '\030', '\001', ' ', '\001', '(', '\013', '2', '\034', '.', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'p', 'r', 'o', 't', 'o', 'b', 'u', 'f', 
-'.', 'U', 'I', 'n', 't', '3', '2', 'V', 'a', 'l', 'u', 'e', 'B', '\013', '\030', '\001', '\222', '\307', '\206', '\330', '\004', '\003', '3', '.', '0', 
-'R', '\016', 'm', 'a', 'x', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'S', 'i', 'z', 'e', ':', '0', '\232', '\305', '\210', '\036', '+', '\n', ')', 
-'e', 'n', 'v', 'o', 'y', '.', 't', 'y', 'p', 'e', '.', 'm', 'a', 't', 'c', 'h', 'e', 'r', '.', 'R', 'e', 'g', 'e', 'x', 'M', 
-'a', 't', 'c', 'h', 'e', 'r', '.', 'G', 'o', 'o', 'g', 'l', 'e', 'R', 'E', '2', ':', '&', '\232', '\305', '\210', '\036', '!', '\n', '\037', 
-'e', 'n', 'v', 'o', 'y', '.', 't', 'y', 'p', 'e', '.', 'm', 'a', 't', 'c', 'h', 'e', 'r', '.', 'R', 'e', 'g', 'e', 'x', 'M', 
-'a', 't', 'c', 'h', 'e', 'r', 'B', '\r', '\n', '\013', 'e', 'n', 'g', 'i', 'n', 'e', '_', 't', 'y', 'p', 'e', '\"', '\306', '\001', '\n', 
-'\027', 'R', 'e', 'g', 'e', 'x', 'M', 'a', 't', 'c', 'h', 'A', 'n', 'd', 'S', 'u', 'b', 's', 't', 'i', 't', 'u', 't', 'e', '\022', 
-'G', '\n', '\007', 'p', 'a', 't', 't', 'e', 'r', 'n', '\030', '\001', ' ', '\001', '(', '\013', '2', '#', '.', 'e', 'n', 'v', 'o', 'y', '.', 
-'t', 'y', 'p', 'e', '.', 'm', 'a', 't', 'c', 'h', 'e', 'r', '.', 'v', '3', '.', 'R', 'e', 'g', 'e', 'x', 'M', 'a', 't', 'c', 
-'h', 'e', 'r', 'B', '\010', '\372', 'B', '\005', '\212', '\001', '\002', '\020', '\001', 'R', '\007', 'p', 'a', 't', 't', 'e', 'r', 'n', '\022', '/', '\n', 
-'\014', 's', 'u', 'b', 's', 't', 'i', 't', 'u', 't', 'i', 'o', 'n', '\030', '\002', ' ', '\001', '(', '\t', 'B', '\013', '\372', 'B', '\010', 'r', 
-'\006', '\300', '\001', '\002', '\310', '\001', '\000', 'R', '\014', 's', 'u', 'b', 's', 't', 'i', 't', 'u', 't', 'i', 'o', 'n', ':', '1', '\232', '\305', 
-'\210', '\036', ',', '\n', '*', 'e', 'n', 'v', 'o', 'y', '.', 't', 'y', 'p', 'e', '.', 'm', 'a', 't', 'c', 'h', 'e', 'r', '.', 'R', 
-'e', 'g', 'e', 'x', 'M', 'a', 't', 'c', 'h', 'A', 'n', 'd', 'S', 'u', 'b', 's', 't', 'i', 't', 'u', 't', 'e', 'B', '\203', '\001', 
-'\n', '#', 'i', 'o', '.', 'e', 'n', 'v', 'o', 'y', 'p', 'r', 'o', 'x', 'y', '.', 'e', 'n', 'v', 'o', 'y', '.', 't', 'y', 'p', 
-'e', '.', 'm', 'a', 't', 'c', 'h', 'e', 'r', '.', 'v', '3', 'B', '\n', 'R', 'e', 'g', 'e', 'x', 'P', 'r', 'o', 't', 'o', 'P', 
-'\001', 'Z', 'F', 'g', 'i', 't', 'h', 'u', 'b', '.', 'c', 'o', 'm', '/', 'e', 'n', 'v', 'o', 'y', 'p', 'r', 'o', 'x', 'y', '/', 
-'g', 'o', '-', 'c', 'o', 'n', 't', 'r', 'o', 'l', '-', 'p', 'l', 'a', 'n', 'e', '/', 'e', 'n', 'v', 'o', 'y', '/', 't', 'y', 
-'p', 'e', '/', 'm', 'a', 't', 'c', 'h', 'e', 'r', '/', 'v', '3', ';', 'm', 'a', 't', 'c', 'h', 'e', 'r', 'v', '3', '\272', '\200', 
-'\310', '\321', '\006', '\002', '\020', '\002', 'b', '\006', 'p', 'r', 'o', 't', 'o', '3', 
+'E', '2', 'B', '\013', '\030', '\001', '\222', '\307', '\206', '\330', '\004', '\003', '3', '.', '0', 'H', '\000', 'R', '\t', 'g', 'o', 'o', 'g', 'l', 'e', 
+'R', 'e', '2', '\022', '\035', '\n', '\005', 'r', 'e', 'g', 'e', 'x', '\030', '\002', ' ', '\001', '(', '\t', 'B', '\007', '\372', 'B', '\004', 'r', '\002', 
+'\020', '\001', 'R', '\005', 'r', 'e', 'g', 'e', 'x', '\032', '\222', '\001', '\n', '\t', 'G', 'o', 'o', 'g', 'l', 'e', 'R', 'E', '2', '\022', 'S', 
+'\n', '\020', 'm', 'a', 'x', '_', 'p', 'r', 'o', 'g', 'r', 'a', 'm', '_', 's', 'i', 'z', 'e', '\030', '\001', ' ', '\001', '(', '\013', '2', 
+'\034', '.', 'g', 'o', 'o', 'g', 'l', 'e', '.', 'p', 'r', 'o', 't', 'o', 'b', 'u', 'f', '.', 'U', 'I', 'n', 't', '3', '2', 'V', 
+'a', 'l', 'u', 'e', 'B', '\013', '\030', '\001', '\222', '\307', '\206', '\330', '\004', '\003', '3', '.', '0', 'R', '\016', 'm', 'a', 'x', 'P', 'r', 'o', 
+'g', 'r', 'a', 'm', 'S', 'i', 'z', 'e', ':', '0', '\232', '\305', '\210', '\036', '+', '\n', ')', 'e', 'n', 'v', 'o', 'y', '.', 't', 'y', 
+'p', 'e', '.', 'm', 'a', 't', 'c', 'h', 'e', 'r', '.', 'R', 'e', 'g', 'e', 'x', 'M', 'a', 't', 'c', 'h', 'e', 'r', '.', 'G', 
+'o', 'o', 'g', 'l', 'e', 'R', 'E', '2', ':', '&', '\232', '\305', '\210', '\036', '!', '\n', '\037', 'e', 'n', 'v', 'o', 'y', '.', 't', 'y', 
+'p', 'e', '.', 'm', 'a', 't', 'c', 'h', 'e', 'r', '.', 'R', 'e', 'g', 'e', 'x', 'M', 'a', 't', 'c', 'h', 'e', 'r', 'B', '\r', 
+'\n', '\013', 'e', 'n', 'g', 'i', 'n', 'e', '_', 't', 'y', 'p', 'e', '\"', '\306', '\001', '\n', '\027', 'R', 'e', 'g', 'e', 'x', 'M', 'a', 
+'t', 'c', 'h', 'A', 'n', 'd', 'S', 'u', 'b', 's', 't', 'i', 't', 'u', 't', 'e', '\022', 'G', '\n', '\007', 'p', 'a', 't', 't', 'e', 
+'r', 'n', '\030', '\001', ' ', '\001', '(', '\013', '2', '#', '.', 'e', 'n', 'v', 'o', 'y', '.', 't', 'y', 'p', 'e', '.', 'm', 'a', 't', 
+'c', 'h', 'e', 'r', '.', 'v', '3', '.', 'R', 'e', 'g', 'e', 'x', 'M', 'a', 't', 'c', 'h', 'e', 'r', 'B', '\010', '\372', 'B', '\005', 
+'\212', '\001', '\002', '\020', '\001', 'R', '\007', 'p', 'a', 't', 't', 'e', 'r', 'n', '\022', '/', '\n', '\014', 's', 'u', 'b', 's', 't', 'i', 't', 
+'u', 't', 'i', 'o', 'n', '\030', '\002', ' ', '\001', '(', '\t', 'B', '\013', '\372', 'B', '\010', 'r', '\006', '\300', '\001', '\002', '\310', '\001', '\000', 'R', 
+'\014', 's', 'u', 'b', 's', 't', 'i', 't', 'u', 't', 'i', 'o', 'n', ':', '1', '\232', '\305', '\210', '\036', ',', '\n', '*', 'e', 'n', 'v', 
+'o', 'y', '.', 't', 'y', 'p', 'e', '.', 'm', 'a', 't', 'c', 'h', 'e', 'r', '.', 'R', 'e', 'g', 'e', 'x', 'M', 'a', 't', 'c', 
+'h', 'A', 'n', 'd', 'S', 'u', 'b', 's', 't', 'i', 't', 'u', 't', 'e', 'B', '\203', '\001', '\n', '#', 'i', 'o', '.', 'e', 'n', 'v', 
+'o', 'y', 'p', 'r', 'o', 'x', 'y', '.', 'e', 'n', 'v', 'o', 'y', '.', 't', 'y', 'p', 'e', '.', 'm', 'a', 't', 'c', 'h', 'e', 
+'r', '.', 'v', '3', 'B', '\n', 'R', 'e', 'g', 'e', 'x', 'P', 'r', 'o', 't', 'o', 'P', '\001', 'Z', 'F', 'g', 'i', 't', 'h', 'u', 
+'b', '.', 'c', 'o', 'm', '/', 'e', 'n', 'v', 'o', 'y', 'p', 'r', 'o', 'x', 'y', '/', 'g', 'o', '-', 'c', 'o', 'n', 't', 'r', 
+'o', 'l', '-', 'p', 'l', 'a', 'n', 'e', '/', 'e', 'n', 'v', 'o', 'y', '/', 't', 'y', 'p', 'e', '/', 'm', 'a', 't', 'c', 'h', 
+'e', 'r', '/', 'v', '3', ';', 'm', 'a', 't', 'c', 'h', 'e', 'r', 'v', '3', '\272', '\200', '\310', '\321', '\006', '\002', '\020', '\002', 'b', '\006', 
+'p', 'r', 'o', 't', 'o', '3', 
 };
 
 static _upb_DefPool_Init *deps[6] = {
@@ -67,5 +67,5 @@ _upb_DefPool_Init envoy_type_matcher_v3_regex_proto_upbdefinit = {
   deps,
   &envoy_type_matcher_v3_regex_proto_upb_file_layout,
   "envoy/type/matcher/v3/regex.proto",
-  UPB_STRINGVIEW_INIT(descriptor, 914)
+  UPB_STRINGVIEW_INIT(descriptor, 906)
 };

data/src/core/ext/xds/xds_bootstrap_grpc.cc

@@ -78,20 +78,6 @@ const JsonLoaderInterface* GrpcXdsBootstrap::GrpcNode::JsonLoader(
   return loader;
 }
 
-//
-// GrpcXdsBootstrap::GrpcXdsServer::ChannelCreds
-//
-
-const JsonLoaderInterface*
-GrpcXdsBootstrap::GrpcXdsServer::ChannelCreds::JsonLoader(const JsonArgs&) {
-  static const auto* loader =
-      JsonObjectLoader<ChannelCreds>()
-          .Field("type", &ChannelCreds::type)
-          .OptionalField("config", &ChannelCreds::config)
-          .Finish();
-  return loader;
-}
-
 //
 // GrpcXdsBootstrap::GrpcXdsServer
 //
@@ -111,8 +97,8 @@ bool GrpcXdsBootstrap::GrpcXdsServer::IgnoreResourceDeletion() const {
 bool GrpcXdsBootstrap::GrpcXdsServer::Equals(const XdsServer& other) const {
   const auto& o = static_cast<const GrpcXdsServer&>(other);
   return (server_uri_ == o.server_uri_ &&
-          channel_creds_.type == o.channel_creds_.type &&
-          channel_creds_.config == o.channel_creds_.config &&
+          channel_creds_config_->type() == o.channel_creds_config_->type() &&
+          channel_creds_config_->Equals(*o.channel_creds_config_) &&
           server_features_ == o.server_features_);
 }
 
@@ -125,6 +111,24 @@ const JsonLoaderInterface* GrpcXdsBootstrap::GrpcXdsServer::JsonLoader(
   return loader;
 }
 
+namespace {
+
+struct ChannelCreds {
+  std::string type;
+  Json::Object config;
+
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
+    static const auto* loader =
+        JsonObjectLoader<ChannelCreds>()
+            .Field("type", &ChannelCreds::type)
+            .OptionalField("config", &ChannelCreds::config)
+            .Finish();
+    return loader;
+  }
+};
+
+}  // namespace
+
 void GrpcXdsBootstrap::GrpcXdsServer::JsonPostLoad(const Json& json,
                                                    const JsonArgs& args,
                                                    ValidationErrors* errors) {
@@ -136,21 +140,20 @@ void GrpcXdsBootstrap::GrpcXdsServer::JsonPostLoad(const Json& json,
     for (size_t i = 0; i < channel_creds_list->size(); ++i) {
       ValidationErrors::ScopedField field(errors, absl::StrCat("[", i, "]"));
       auto& creds = (*channel_creds_list)[i];
-      // Select the first channel creds type that we support.
-      if (channel_creds_.type.empty() &&
-          CoreConfiguration::Get().channel_creds_registry().IsSupported(
+      // Select the first channel creds type that we support, but
+      // validate all entries.
+      if (CoreConfiguration::Get().channel_creds_registry().IsSupported(
               creds.type)) {
-        if (!CoreConfiguration::Get().channel_creds_registry().IsValidConfig(
-                creds.type, Json::FromObject(creds.config))) {
-          errors->AddError(absl::StrCat(
-              "invalid config for channel creds type \"", creds.type, "\""));
-          continue;
+        ValidationErrors::ScopedField field(errors, ".config");
+        auto config =
+            CoreConfiguration::Get().channel_creds_registry().ParseConfig(
+                creds.type, Json::FromObject(creds.config), args, errors);
+        if (channel_creds_config_ == nullptr) {
+          channel_creds_config_ = std::move(config);
         }
-        channel_creds_.type = std::move(creds.type);
-        channel_creds_.config = std::move(creds.config);
       }
     }
-    if (channel_creds_.type.empty()) {
+    if (channel_creds_config_ == nullptr) {
       errors->AddError("no known creds type found");
     }
   }
@@ -176,10 +179,10 @@ void GrpcXdsBootstrap::GrpcXdsServer::JsonPostLoad(const Json& json,
 
 Json GrpcXdsBootstrap::GrpcXdsServer::ToJson() const {
   Json::Object channel_creds_json{
-      {"type", Json::FromString(channel_creds_.type)},
+      {"type", Json::FromString(std::string(channel_creds_config_->type()))},
   };
-  if (!channel_creds_.config.empty()) {
-    channel_creds_json["config"] = Json::FromObject(channel_creds_.config);
+  if (channel_creds_config_ != nullptr) {
+    channel_creds_json["config"] = channel_creds_config_->ToJson();
   }
   Json::Object json{
       {"server_uri", Json::FromString(server_uri_)},

data/src/core/ext/xds/xds_bootstrap_grpc.h

@@ -35,10 +35,12 @@
 #include "src/core/ext/xds/xds_cluster_specifier_plugin.h"
 #include "src/core/ext/xds/xds_http_filters.h"
 #include "src/core/ext/xds/xds_lb_policy_registry.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/validation_errors.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/security/credentials/channel_creds_registry.h"
 
 namespace grpc_core {
 
@@ -82,11 +84,8 @@ class GrpcXdsBootstrap : public XdsBootstrap {
 
     bool Equals(const XdsServer& other) const override;
 
-    const std::string& channel_creds_type() const {
-      return channel_creds_.type;
-    }
-    const Json::Object& channel_creds_config() const {
-      return channel_creds_.config;
+    RefCountedPtr<ChannelCredsConfig> channel_creds_config() const {
+      return channel_creds_config_;
     }
 
     static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
@@ -96,15 +95,8 @@ class GrpcXdsBootstrap : public XdsBootstrap {
     Json ToJson() const;
 
    private:
-    struct ChannelCreds {
-      std::string type;
-      Json::Object config;
-
-      static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
-    };
-
     std::string server_uri_;
-    ChannelCreds channel_creds_;
+    RefCountedPtr<ChannelCredsConfig> channel_creds_config_;
     std::set<std::string> server_features_;
   };
 

data/src/core/ext/xds/xds_client_grpc.cc

@@ -145,8 +145,10 @@ absl::StatusOr<RefCountedPtr<GrpcXdsClient>> GrpcXdsClient::GetOrCreate(
     if (!bootstrap.ok()) return bootstrap.status();
     grpc_channel_args* xds_channel_args = args.GetPointer<grpc_channel_args>(
         GRPC_ARG_TEST_ONLY_DO_NOT_USE_IN_PROD_XDS_CLIENT_CHANNEL_ARGS);
-    return MakeRefCounted<GrpcXdsClient>(std::move(*bootstrap),
-                                         ChannelArgs::FromC(xds_channel_args));
+    auto channel_args = ChannelArgs::FromC(xds_channel_args);
+    return MakeRefCounted<GrpcXdsClient>(
+        std::move(*bootstrap), channel_args,
+        MakeOrphanable<GrpcXdsTransportFactory>(channel_args));
   }
   // Otherwise, use the global instance.
   MutexLock lock(g_mu);
@@ -165,16 +167,19 @@ absl::StatusOr<RefCountedPtr<GrpcXdsClient>> GrpcXdsClient::GetOrCreate(
   auto bootstrap = GrpcXdsBootstrap::Create(*bootstrap_contents);
   if (!bootstrap.ok()) return bootstrap.status();
   // Instantiate XdsClient.
+  auto channel_args = ChannelArgs::FromC(g_channel_args);
   auto xds_client = MakeRefCounted<GrpcXdsClient>(
-      std::move(*bootstrap), ChannelArgs::FromC(g_channel_args));
+      std::move(*bootstrap), channel_args,
+      MakeOrphanable<GrpcXdsTransportFactory>(channel_args));
   g_xds_client = xds_client.get();
   return xds_client;
 }
 
-GrpcXdsClient::GrpcXdsClient(std::unique_ptr<GrpcXdsBootstrap> bootstrap,
-                             const ChannelArgs& args)
+GrpcXdsClient::GrpcXdsClient(
+    std::unique_ptr<GrpcXdsBootstrap> bootstrap, const ChannelArgs& args,
+    OrphanablePtr<XdsTransportFactory> transport_factory)
     : XdsClient(
-          std::move(bootstrap), MakeOrphanable<GrpcXdsTransportFactory>(args),
+          std::move(bootstrap), std::move(transport_factory),
           grpc_event_engine::experimental::GetDefaultEventEngine(),
           absl::StrCat("gRPC C-core ", GPR_PLATFORM_STRING,
                        GRPC_XDS_USER_AGENT_NAME_SUFFIX_STRING),

data/src/core/ext/xds/xds_client_grpc.h

@@ -29,11 +29,13 @@
 #include "src/core/ext/xds/certificate_provider_store.h"
 #include "src/core/ext/xds/xds_bootstrap_grpc.h"
 #include "src/core/ext/xds/xds_client.h"
+#include "src/core/ext/xds/xds_transport.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
+#include "src/core/lib/resolver/server_address.h"
 
 namespace grpc_core {
 
@@ -44,13 +46,25 @@ class GrpcXdsClient : public XdsClient {
       const ChannelArgs& args, const char* reason);
 
   // Do not instantiate directly -- use GetOrCreate() instead.
+  // TODO(roth): The transport factory is injectable here to support
+  // tests that want to use a fake transport factory with code that
+  // expects a GrpcXdsClient instead of an XdsClient, typically because
+  // it needs to call the interested_parties() method.  Once we
+  // finish the EventEngine migration and remove the interested_parties()
+  // method, consider instead changing callers to an approach where the
+  // production code uses XdsClient instead of GrpcXdsClient, and then
+  // passing in a fake XdsClient impl in the tests.  Note that this will
+  // work for callers that use interested_parties() but not for callers
+  // that also use certificate_provider_store(), but we should consider
+  // alternatives for that case as well.
   GrpcXdsClient(std::unique_ptr<GrpcXdsBootstrap> bootstrap,
-                const ChannelArgs& args);
+                const ChannelArgs& args,
+                OrphanablePtr<XdsTransportFactory> transport_factory);
   ~GrpcXdsClient() override;
 
   // Helpers for encoding the XdsClient object in channel args.
   static absl::string_view ChannelArgName() {
-    return "grpc.internal.xds_client";
+    return GRPC_ARG_NO_SUBCHANNEL_PREFIX "xds_client";
   }
   static int ChannelArgsCompare(const XdsClient* a, const XdsClient* b) {
     return QsortCompare(a, b);

data/src/core/ext/xds/xds_client_stats.h

@@ -38,6 +38,7 @@
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/resolver/server_address.h"
 
 namespace grpc_core {
 
@@ -95,6 +96,15 @@ class XdsLocalityName : public RefCounted<XdsLocalityName> {
     return human_readable_string_;
   }
 
+  // Channel args traits.
+  static absl::string_view ChannelArgName() {
+    return GRPC_ARG_NO_SUBCHANNEL_PREFIX "xds_locality_name";
+  }
+  static int ChannelArgsCompare(const XdsLocalityName* a,
+                                const XdsLocalityName* b) {
+    return a->Compare(*b);
+  }
+
  private:
   std::string region_;
   std::string zone_;

data/src/core/ext/xds/xds_cluster.cc

@@ -24,6 +24,7 @@
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/strip.h"
@@ -187,23 +188,32 @@ XdsClusterResource::Eds EdsConfigParse(
   if (eds_cluster_config == nullptr) {
     errors->AddError("field not present");
   } else {
-    ValidationErrors::ScopedField field(errors, ".eds_config");
-    const envoy_config_core_v3_ConfigSource* eds_config =
-        envoy_config_cluster_v3_Cluster_EdsClusterConfig_eds_config(
-            eds_cluster_config);
-    if (eds_config == nullptr) {
-      errors->AddError("field not present");
-    } else {
-      if (!envoy_config_core_v3_ConfigSource_has_ads(eds_config) &&
-          !envoy_config_core_v3_ConfigSource_has_self(eds_config)) {
-        errors->AddError("ConfigSource is not ads or self");
-      }
-      // Record EDS service_name (if any).
-      upb_StringView service_name =
-          envoy_config_cluster_v3_Cluster_EdsClusterConfig_service_name(
+    // Validate ConfigSource.
+    {
+      ValidationErrors::ScopedField field(errors, ".eds_config");
+      const envoy_config_core_v3_ConfigSource* eds_config =
+          envoy_config_cluster_v3_Cluster_EdsClusterConfig_eds_config(
               eds_cluster_config);
-      if (service_name.size != 0) {
-        eds.eds_service_name = UpbStringToStdString(service_name);
+      if (eds_config == nullptr) {
+        errors->AddError("field not present");
+      } else {
+        if (!envoy_config_core_v3_ConfigSource_has_ads(eds_config) &&
+            !envoy_config_core_v3_ConfigSource_has_self(eds_config)) {
+          errors->AddError("ConfigSource is not ads or self");
+        }
+      }
+    }
+    // Record EDS service_name (if any).
+    // This field is required if the CDS resource has an xdstp name.
+    eds.eds_service_name = UpbStringToStdString(
+        envoy_config_cluster_v3_Cluster_EdsClusterConfig_service_name(
+            eds_cluster_config));
+    if (eds.eds_service_name.empty()) {
+      absl::string_view cluster_name =
+          UpbStringToAbsl(envoy_config_cluster_v3_Cluster_name(cluster));
+      if (absl::StartsWith(cluster_name, "xdstp:")) {
+        ValidationErrors::ScopedField field(errors, ".service_name");
+        errors->AddError("must be set if Cluster resource has an xdstp name");
       }
     }
   }

data/src/core/ext/xds/xds_endpoint.cc

@@ -220,13 +220,10 @@ absl::optional<ServerAddress> ServerAddressParse(
     }
   }
   // Convert to ServerAddress.
-  std::map<const char*, std::unique_ptr<ServerAddress::AttributeInterface>>
-      attributes;
-  attributes[ServerAddressWeightAttribute::kServerAddressWeightAttributeKey] =
-      std::make_unique<ServerAddressWeightAttribute>(weight);
-  attributes[XdsEndpointHealthStatusAttribute::kKey] =
-      std::make_unique<XdsEndpointHealthStatusAttribute>(*status);
-  return ServerAddress(grpc_address, ChannelArgs(), std::move(attributes));
+  return ServerAddress(grpc_address,
+                       ChannelArgs()
+                           .Set(GRPC_ARG_ADDRESS_WEIGHT, weight)
+                           .Set(GRPC_ARG_XDS_HEALTH_STATUS, status->status()));
 }
 
 struct ParsedLocality {

data/src/core/ext/xds/xds_health_status.cc

@@ -18,11 +18,8 @@
 
 #include "src/core/ext/xds/xds_health_status.h"
 
-#include "absl/strings/str_cat.h"
 #include "envoy/config/core/v3/health_check.upb.h"
 
-#include "src/core/lib/gpr/useful.h"
-
 namespace grpc_core {
 
 absl::optional<XdsHealthStatus> XdsHealthStatus::FromUpb(uint32_t status) {
@@ -63,18 +60,4 @@ bool operator<(const XdsHealthStatus& hs1, const XdsHealthStatus& hs2) {
   return hs1.status() < hs2.status();
 }
 
-const char* XdsEndpointHealthStatusAttribute::kKey =
-    "xds_endpoint_health_status";
-
-int XdsEndpointHealthStatusAttribute::Cmp(
-    const AttributeInterface* other) const {
-  const auto* other_attr =
-      static_cast<const XdsEndpointHealthStatusAttribute*>(other);
-  return QsortCompare(status_, other_attr->status_);
-}
-
-std::string XdsEndpointHealthStatusAttribute::ToString() const {
-  return absl::StrCat("{status_=", status_.ToString(), "}");
-}
-
 }  // namespace grpc_core

data/src/core/ext/xds/xds_health_status.h

@@ -21,15 +21,17 @@
 
 #include <stdint.h>
 
-#include <memory>
-#include <string>
-
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 #include "absl/types/span.h"
 
 #include "src/core/lib/resolver/server_address.h"
 
+// Channel arg key for xDS health status.
+// Value is an XdsHealthStatus::HealthStatus enum.
+#define GRPC_ARG_XDS_HEALTH_STATUS \
+  GRPC_ARG_NO_SUBCHANNEL_PREFIX "xds_health_status"
+
 namespace grpc_core {
 
 class XdsHealthStatus {
@@ -82,28 +84,6 @@ class XdsHealthStatusSet {
 
 bool operator<(const XdsHealthStatus& hs1, const XdsHealthStatus& hs2);
 
-class XdsEndpointHealthStatusAttribute
-    : public ServerAddress::AttributeInterface {
- public:
-  static const char* kKey;
-
-  explicit XdsEndpointHealthStatusAttribute(XdsHealthStatus status)
-      : status_(status) {}
-
-  XdsHealthStatus status() const { return status_; }
-
-  std::unique_ptr<AttributeInterface> Copy() const override {
-    return std::make_unique<XdsEndpointHealthStatusAttribute>(status_);
-  }
-
-  int Cmp(const AttributeInterface* other) const override;
-
-  std::string ToString() const override;
-
- private:
-  XdsHealthStatus status_;
-};
-
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_EXT_XDS_XDS_HEALTH_STATUS_H

data/src/core/ext/xds/xds_lb_policy_registry.cc

@@ -29,12 +29,14 @@
 #include "absl/types/variant.h"
 #include "envoy/config/core/v3/extension.upb.h"
 #include "envoy/extensions/load_balancing_policies/client_side_weighted_round_robin/v3/client_side_weighted_round_robin.upb.h"
+#include "envoy/extensions/load_balancing_policies/pick_first/v3/pick_first.upb.h"
 #include "envoy/extensions/load_balancing_policies/ring_hash/v3/ring_hash.upb.h"
 #include "envoy/extensions/load_balancing_policies/wrr_locality/v3/wrr_locality.upb.h"
 #include "google/protobuf/wrappers.upb.h"
 
 #include <grpc/support/json.h>
 
+#include "src/core/ext/filters/client_channel/lb_policy/pick_first/pick_first.h"
 #include "src/core/ext/xds/xds_common_types.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/time.h"
@@ -254,6 +256,38 @@ class WrrLocalityLbPolicyConfigFactory
   }
 };
 
+class PickFirstLbPolicyConfigFactory
+    : public XdsLbPolicyRegistry::ConfigFactory {
+ public:
+  Json::Object ConvertXdsLbPolicyConfig(
+      const XdsLbPolicyRegistry* /*registry*/,
+      const XdsResourceType::DecodeContext& context,
+      absl::string_view configuration, ValidationErrors* errors,
+      int /*recursion_depth*/) override {
+    const auto* resource =
+        envoy_extensions_load_balancing_policies_pick_first_v3_PickFirst_parse(
+            configuration.data(), configuration.size(), context.arena);
+    if (resource == nullptr) {
+      errors->AddError("can't decode PickFirst LB policy config");
+      return {};
+    }
+    bool shuffle_address_list =
+        envoy_extensions_load_balancing_policies_pick_first_v3_PickFirst_shuffle_address_list(
+            resource);
+    return Json::Object{
+        {"pick_first",
+         Json::FromObject({
+             {"shuffleAddressList", Json::FromBool(shuffle_address_list)},
+         })}};
+  }
+
+  absl::string_view type() override { return Type(); }
+
+  static absl::string_view Type() {
+    return "envoy.extensions.load_balancing_policies.pick_first.v3.PickFirst";
+  }
+};
+
 }  // namespace
 
 //
@@ -273,6 +307,11 @@ XdsLbPolicyRegistry::XdsLbPolicyRegistry() {
   policy_config_factories_.emplace(
       WrrLocalityLbPolicyConfigFactory::Type(),
       std::make_unique<WrrLocalityLbPolicyConfigFactory>());
+  if (ShufflePickFirstEnabled()) {
+    policy_config_factories_.emplace(
+        PickFirstLbPolicyConfigFactory::Type(),
+        std::make_unique<PickFirstLbPolicyConfigFactory>());
+  }
 }
 
 Json::Array XdsLbPolicyRegistry::ConvertXdsLbPolicyConfig(