grpc 1.26.0 → 1.28.0

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

@@ -70,7 +70,7 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
     virtual ~Parser() = default;
 
     virtual std::unique_ptr<ParsedConfig> ParseGlobalParams(
-        const grpc_json* /* json */, grpc_error** error) {
+        const Json& /* json */, grpc_error** error) {
       // Avoid unused parameter warning on debug-only parameter
       (void)error;
       GPR_DEBUG_ASSERT(error != nullptr);
@@ -78,7 +78,7 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
     }
 
     virtual std::unique_ptr<ParsedConfig> ParsePerMethodParams(
-        const grpc_json* /* json */, grpc_error** error) {
+        const Json& /* json */, grpc_error** error) {
       // Avoid unused parameter warning on debug-only parameter
       (void)error;
       GPR_DEBUG_ASSERT(error != nullptr);
@@ -125,16 +125,12 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
 
   /// Creates a new service config from parsing \a json_string.
   /// Returns null on parse error.
-  static RefCountedPtr<ServiceConfig> Create(const char* json,
+  static RefCountedPtr<ServiceConfig> Create(StringView json_string,
                                              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();
+  ServiceConfig(std::string json_string, Json json, grpc_error** error);
 
-  const char* service_config_json() const { return service_config_json_.get(); }
+  const std::string& json_string() const { return json_string_; }
 
   /// Retrieves the global parsed config at index \a index. The
   /// lifetime of the returned object is tied to the lifetime of the
@@ -163,24 +159,21 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
 
  private:
   // Helper functions to parse the service config
-  grpc_error* ParseGlobalParams(const grpc_json* json_tree);
-  grpc_error* ParsePerMethodParams(const grpc_json* json_tree);
-
-  // Returns the number of names specified in the method config \a json.
-  static int CountNamesInMethodConfig(grpc_json* json);
+  grpc_error* ParseGlobalParams();
+  grpc_error* ParsePerMethodParams();
 
   // Returns a path string for the JSON name object specified by \a json.
   // Returns null on error, and stores error in \a error.
-  static grpc_core::UniquePtr<char> ParseJsonMethodName(grpc_json* json,
-                                                        grpc_error** error);
+  static UniquePtr<char> ParseJsonMethodName(const Json& json,
+                                             grpc_error** error);
 
   grpc_error* ParseJsonMethodConfigToServiceConfigVectorTable(
-      const grpc_json* json,
-      SliceHashTable<const ParsedConfigVector*>::Entry* entries, size_t* idx);
+      const Json& json,
+      InlinedVector<SliceHashTable<const ParsedConfigVector*>::Entry, 10>*
+          entries);
 
-  grpc_core::UniquePtr<char> service_config_json_;
-  grpc_core::UniquePtr<char> json_string_;  // Underlying storage for json_tree.
-  grpc_json* json_tree_;
+  std::string json_string_;
+  Json json_;
 
   InlinedVector<std::unique_ptr<ParsedConfig>, kNumPreallocatedParsers>
       parsed_global_configs_;

data/src/core/ext/filters/client_channel/xds/xds_api.cc

@@ -19,42 +19,52 @@
 #include <grpc/support/port_platform.h>
 
 #include <algorithm>
+#include <cctype>
+#include <cstdlib>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
 
 #include <grpc/impl/codegen/log.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/ext/filters/client_channel/xds/xds_api.h"
+#include "src/core/lib/gprpp/inlined_vector.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/sockaddr_utils.h"
 
+#include "envoy/api/v2/cds.upb.h"
 #include "envoy/api/v2/core/address.upb.h"
 #include "envoy/api/v2/core/base.upb.h"
+#include "envoy/api/v2/core/config_source.upb.h"
 #include "envoy/api/v2/core/health_check.upb.h"
 #include "envoy/api/v2/discovery.upb.h"
 #include "envoy/api/v2/eds.upb.h"
 #include "envoy/api/v2/endpoint/endpoint.upb.h"
 #include "envoy/api/v2/endpoint/load_report.upb.h"
+#include "envoy/api/v2/lds.upb.h"
+#include "envoy/api/v2/rds.upb.h"
+#include "envoy/api/v2/route/route.upb.h"
+#include "envoy/config/filter/network/http_connection_manager/v2/http_connection_manager.upb.h"
+#include "envoy/config/listener/v2/api_listener.upb.h"
 #include "envoy/service/load_stats/v2/lrs.upb.h"
 #include "envoy/type/percent.upb.h"
 #include "google/protobuf/any.upb.h"
 #include "google/protobuf/duration.upb.h"
 #include "google/protobuf/struct.upb.h"
-#include "google/protobuf/timestamp.upb.h"
 #include "google/protobuf/wrappers.upb.h"
+#include "google/rpc/status.upb.h"
 #include "upb/upb.h"
 
 namespace grpc_core {
 
-namespace {
-
-constexpr char kEdsTypeUrl[] =
-    "type.googleapis.com/envoy.api.v2.ClusterLoadAssignment";
-
-}  // namespace
+//
+// XdsApi::PriorityListUpdate
+//
 
-bool XdsPriorityListUpdate::operator==(
-    const XdsPriorityListUpdate& other) const {
+bool XdsApi::PriorityListUpdate::operator==(
+    const XdsApi::PriorityListUpdate& other) const {
   if (priorities_.size() != other.priorities_.size()) return false;
   for (size_t i = 0; i < priorities_.size(); ++i) {
     if (priorities_[i].localities != other.priorities_[i].localities) {
@@ -64,8 +74,8 @@ bool XdsPriorityListUpdate::operator==(
   return true;
 }
 
-void XdsPriorityListUpdate::Add(
-    XdsPriorityListUpdate::LocalityMap::Locality locality) {
+void XdsApi::PriorityListUpdate::Add(
+    XdsApi::PriorityListUpdate::LocalityMap::Locality locality) {
   // Pad the missing priorities in case the localities are not ordered by
   // priority.
   if (!Contains(locality.priority)) priorities_.resize(locality.priority + 1);
@@ -73,13 +83,13 @@ void XdsPriorityListUpdate::Add(
   locality_map.localities.emplace(locality.name, std::move(locality));
 }
 
-const XdsPriorityListUpdate::LocalityMap* XdsPriorityListUpdate::Find(
+const XdsApi::PriorityListUpdate::LocalityMap* XdsApi::PriorityListUpdate::Find(
     uint32_t priority) const {
   if (!Contains(priority)) return nullptr;
   return &priorities_[priority];
 }
 
-bool XdsPriorityListUpdate::Contains(
+bool XdsApi::PriorityListUpdate::Contains(
     const RefCountedPtr<XdsLocalityName>& name) {
   for (size_t i = 0; i < priorities_.size(); ++i) {
     const LocalityMap& locality_map = priorities_[i];
@@ -88,8 +98,11 @@ bool XdsPriorityListUpdate::Contains(
   return false;
 }
 
-bool XdsDropConfig::ShouldDrop(
-    const grpc_core::UniquePtr<char>** category_name) const {
+//
+// XdsApi::DropConfig
+//
+
+bool XdsApi::DropConfig::ShouldDrop(const std::string** category_name) const {
   for (size_t i = 0; i < drop_category_list_.size(); ++i) {
     const auto& drop_category = drop_category_list_[i];
     // Generate a random number in [0, 1000000).
@@ -102,13 +115,33 @@ bool XdsDropConfig::ShouldDrop(
   return false;
 }
 
+//
+// XdsApi
+//
+
+const char* XdsApi::kLdsTypeUrl = "type.googleapis.com/envoy.api.v2.Listener";
+const char* XdsApi::kRdsTypeUrl =
+    "type.googleapis.com/envoy.api.v2.RouteConfiguration";
+const char* XdsApi::kCdsTypeUrl = "type.googleapis.com/envoy.api.v2.Cluster";
+const char* XdsApi::kEdsTypeUrl =
+    "type.googleapis.com/envoy.api.v2.ClusterLoadAssignment";
+
+XdsApi::XdsApi(XdsClient* client, TraceFlag* tracer,
+               const XdsBootstrap::Node* node)
+    : client_(client),
+      tracer_(tracer),
+      node_(node),
+      build_version_(absl::StrCat("gRPC C-core ", GPR_PLATFORM_STRING, " ",
+                                  grpc_version_string())),
+      user_agent_name_(absl::StrCat("gRPC C-core ", GPR_PLATFORM_STRING)) {}
+
 namespace {
 
 void PopulateMetadataValue(upb_arena* arena, google_protobuf_Value* value_pb,
-                           const XdsBootstrap::MetadataValue& value);
+                           const Json& value);
 
 void PopulateListValue(upb_arena* arena, google_protobuf_ListValue* list_value,
-                       const std::vector<XdsBootstrap::MetadataValue>& values) {
+                       const Json::Array& values) {
   for (const auto& value : values) {
     auto* value_pb = google_protobuf_ListValue_add_values(list_value, arena);
     PopulateMetadataValue(arena, value_pb, value);
@@ -116,13 +149,12 @@ void PopulateListValue(upb_arena* arena, google_protobuf_ListValue* list_value,
 }
 
 void PopulateMetadata(upb_arena* arena, google_protobuf_Struct* metadata_pb,
-                      const std::map<const char*, XdsBootstrap::MetadataValue,
-                                     StringLess>& metadata) {
+                      const Json::Object& metadata) {
   for (const auto& p : metadata) {
     google_protobuf_Struct_FieldsEntry* field =
         google_protobuf_Struct_add_fields(metadata_pb, arena);
-    google_protobuf_Struct_FieldsEntry_set_key(field,
-                                               upb_strview_makez(p.first));
+    google_protobuf_Struct_FieldsEntry_set_key(
+        field, upb_strview_makez(p.first.c_str()));
     google_protobuf_Value* value =
         google_protobuf_Struct_FieldsEntry_mutable_value(field, arena);
     PopulateMetadataValue(arena, value, p.second);
@@ -130,98 +162,1079 @@ void PopulateMetadata(upb_arena* arena, google_protobuf_Struct* metadata_pb,
 }
 
 void PopulateMetadataValue(upb_arena* arena, google_protobuf_Value* value_pb,
-                           const XdsBootstrap::MetadataValue& value) {
-  switch (value.type) {
-    case XdsBootstrap::MetadataValue::Type::MD_NULL:
+                           const Json& value) {
+  switch (value.type()) {
+    case Json::Type::JSON_NULL:
       google_protobuf_Value_set_null_value(value_pb, 0);
       break;
-    case XdsBootstrap::MetadataValue::Type::DOUBLE:
-      google_protobuf_Value_set_number_value(value_pb, value.double_value);
+    case Json::Type::NUMBER:
+      google_protobuf_Value_set_number_value(
+          value_pb, strtod(value.string_value().c_str(), nullptr));
       break;
-    case XdsBootstrap::MetadataValue::Type::STRING:
+    case Json::Type::STRING:
       google_protobuf_Value_set_string_value(
-          value_pb, upb_strview_makez(value.string_value));
+          value_pb, upb_strview_makez(value.string_value().c_str()));
+      break;
+    case Json::Type::JSON_TRUE:
+      google_protobuf_Value_set_bool_value(value_pb, true);
       break;
-    case XdsBootstrap::MetadataValue::Type::BOOL:
-      google_protobuf_Value_set_bool_value(value_pb, value.bool_value);
+    case Json::Type::JSON_FALSE:
+      google_protobuf_Value_set_bool_value(value_pb, false);
       break;
-    case XdsBootstrap::MetadataValue::Type::STRUCT: {
+    case Json::Type::OBJECT: {
       google_protobuf_Struct* struct_value =
           google_protobuf_Value_mutable_struct_value(value_pb, arena);
-      PopulateMetadata(arena, struct_value, value.struct_value);
+      PopulateMetadata(arena, struct_value, value.object_value());
       break;
     }
-    case XdsBootstrap::MetadataValue::Type::LIST: {
+    case Json::Type::ARRAY: {
       google_protobuf_ListValue* list_value =
           google_protobuf_Value_mutable_list_value(value_pb, arena);
-      PopulateListValue(arena, list_value, value.list_value);
+      PopulateListValue(arena, list_value, value.array_value());
       break;
     }
   }
 }
 
 void PopulateNode(upb_arena* arena, const XdsBootstrap::Node* node,
-                  const char* build_version, envoy_api_v2_core_Node* node_msg) {
+                  const std::string& build_version,
+                  const std::string& user_agent_name,
+                  const std::string& server_name,
+                  envoy_api_v2_core_Node* node_msg) {
   if (node != nullptr) {
-    if (node->id != nullptr) {
-      envoy_api_v2_core_Node_set_id(node_msg, upb_strview_makez(node->id));
+    if (!node->id.empty()) {
+      envoy_api_v2_core_Node_set_id(node_msg,
+                                    upb_strview_makez(node->id.c_str()));
     }
-    if (node->cluster != nullptr) {
-      envoy_api_v2_core_Node_set_cluster(node_msg,
-                                         upb_strview_makez(node->cluster));
+    if (!node->cluster.empty()) {
+      envoy_api_v2_core_Node_set_cluster(
+          node_msg, upb_strview_makez(node->cluster.c_str()));
     }
-    if (!node->metadata.empty()) {
+    if (!node->metadata.object_value().empty()) {
       google_protobuf_Struct* metadata =
           envoy_api_v2_core_Node_mutable_metadata(node_msg, arena);
-      PopulateMetadata(arena, metadata, node->metadata);
+      PopulateMetadata(arena, metadata, node->metadata.object_value());
+    }
+    if (!server_name.empty()) {
+      google_protobuf_Struct* metadata =
+          envoy_api_v2_core_Node_mutable_metadata(node_msg, arena);
+      google_protobuf_Struct_FieldsEntry* field =
+          google_protobuf_Struct_add_fields(metadata, arena);
+      google_protobuf_Struct_FieldsEntry_set_key(
+          field, upb_strview_makez("PROXYLESS_CLIENT_HOSTNAME"));
+      google_protobuf_Value* value =
+          google_protobuf_Struct_FieldsEntry_mutable_value(field, arena);
+      google_protobuf_Value_set_string_value(
+          value, upb_strview_make(server_name.data(), server_name.size()));
     }
-    if (node->locality_region != nullptr || node->locality_zone != nullptr ||
-        node->locality_subzone != nullptr) {
+    if (!node->locality_region.empty() || !node->locality_zone.empty() ||
+        !node->locality_subzone.empty()) {
       envoy_api_v2_core_Locality* locality =
           envoy_api_v2_core_Node_mutable_locality(node_msg, arena);
-      if (node->locality_region != nullptr) {
+      if (!node->locality_region.empty()) {
         envoy_api_v2_core_Locality_set_region(
-            locality, upb_strview_makez(node->locality_region));
+            locality, upb_strview_makez(node->locality_region.c_str()));
       }
-      if (node->locality_zone != nullptr) {
+      if (!node->locality_zone.empty()) {
         envoy_api_v2_core_Locality_set_zone(
-            locality, upb_strview_makez(node->locality_zone));
+            locality, upb_strview_makez(node->locality_zone.c_str()));
       }
-      if (node->locality_subzone != nullptr) {
+      if (!node->locality_subzone.empty()) {
         envoy_api_v2_core_Locality_set_sub_zone(
-            locality, upb_strview_makez(node->locality_subzone));
+            locality, upb_strview_makez(node->locality_subzone.c_str()));
       }
     }
   }
-  envoy_api_v2_core_Node_set_build_version(node_msg,
-                                           upb_strview_makez(build_version));
+  envoy_api_v2_core_Node_set_build_version(
+      node_msg, upb_strview_make(build_version.data(), build_version.size()));
+  envoy_api_v2_core_Node_set_user_agent_name(
+      node_msg,
+      upb_strview_make(user_agent_name.data(), user_agent_name.size()));
+  envoy_api_v2_core_Node_set_user_agent_version(
+      node_msg, upb_strview_makez(grpc_version_string()));
+  envoy_api_v2_core_Node_add_client_features(
+      node_msg, upb_strview_makez("envoy.lb.does_not_support_overprovisioning"),
+      arena);
 }
 
-}  // namespace
-
-grpc_slice XdsEdsRequestCreateAndEncode(const char* server_name,
-                                        const XdsBootstrap::Node* node,
-                                        const char* build_version) {
-  upb::Arena arena;
+envoy_api_v2_DiscoveryRequest* CreateDiscoveryRequest(
+    upb_arena* arena, const char* type_url, const std::string& version,
+    const std::string& nonce, grpc_error* error) {
   // Create a request.
   envoy_api_v2_DiscoveryRequest* request =
-      envoy_api_v2_DiscoveryRequest_new(arena.ptr());
-  envoy_api_v2_core_Node* node_msg =
-      envoy_api_v2_DiscoveryRequest_mutable_node(request, arena.ptr());
-  PopulateNode(arena.ptr(), node, build_version, node_msg);
-  envoy_api_v2_DiscoveryRequest_add_resource_names(
-      request, upb_strview_makez(server_name), arena.ptr());
+      envoy_api_v2_DiscoveryRequest_new(arena);
+  // Set type_url.
   envoy_api_v2_DiscoveryRequest_set_type_url(request,
-                                             upb_strview_makez(kEdsTypeUrl));
-  // Encode the request.
+                                             upb_strview_makez(type_url));
+  // Set version_info.
+  if (!version.empty()) {
+    envoy_api_v2_DiscoveryRequest_set_version_info(
+        request, upb_strview_makez(version.c_str()));
+  }
+  // Set nonce.
+  if (!nonce.empty()) {
+    envoy_api_v2_DiscoveryRequest_set_response_nonce(
+        request, upb_strview_makez(nonce.c_str()));
+  }
+  // Set error_detail if it's a NACK.
+  if (error != GRPC_ERROR_NONE) {
+    grpc_slice error_description_slice;
+    GPR_ASSERT(grpc_error_get_str(error, GRPC_ERROR_STR_DESCRIPTION,
+                                  &error_description_slice));
+    upb_strview error_description_strview =
+        upb_strview_make(reinterpret_cast<const char*>(
+                             GPR_SLICE_START_PTR(error_description_slice)),
+                         GPR_SLICE_LENGTH(error_description_slice));
+    google_rpc_Status* error_detail =
+        envoy_api_v2_DiscoveryRequest_mutable_error_detail(request, arena);
+    google_rpc_Status_set_message(error_detail, error_description_strview);
+    GRPC_ERROR_UNREF(error);
+  }
+  return request;
+}
+
+inline absl::string_view UpbStringToAbsl(const upb_strview& str) {
+  return absl::string_view(str.data, str.size);
+}
+
+inline void AddStringField(const char* name, const upb_strview& value,
+                           std::vector<std::string>* fields,
+                           bool add_if_empty = false) {
+  if (value.size > 0 || add_if_empty) {
+    fields->emplace_back(
+        absl::StrCat(name, ": \"", UpbStringToAbsl(value), "\""));
+  }
+}
+
+inline void AddLocalityField(int indent_level,
+                             const envoy_api_v2_core_Locality* locality,
+                             std::vector<std::string>* fields) {
+  std::string indent =
+      absl::StrJoin(std::vector<std::string>(indent_level, "  "), "");
+  // region
+  std::string field = absl::StrCat(indent, "region");
+  AddStringField(field.c_str(), envoy_api_v2_core_Locality_region(locality),
+                 fields);
+  // zone
+  field = absl::StrCat(indent, "zone");
+  AddStringField(field.c_str(), envoy_api_v2_core_Locality_zone(locality),
+                 fields);
+  // sub_zone
+  field = absl::StrCat(indent, "sub_zone");
+  AddStringField(field.c_str(), envoy_api_v2_core_Locality_sub_zone(locality),
+                 fields);
+}
+
+void AddNodeLogFields(const envoy_api_v2_core_Node* node,
+                      std::vector<std::string>* fields) {
+  fields->emplace_back("node {");
+  // id
+  AddStringField("  id", envoy_api_v2_core_Node_id(node), fields);
+  // metadata
+  const google_protobuf_Struct* metadata =
+      envoy_api_v2_core_Node_metadata(node);
+  if (metadata != nullptr) {
+    fields->emplace_back("  metadata {");
+    size_t num_entries;
+    const google_protobuf_Struct_FieldsEntry* const* entries =
+        google_protobuf_Struct_fields(metadata, &num_entries);
+    for (size_t i = 0; i < num_entries; ++i) {
+      fields->emplace_back("    field {");
+      // key
+      AddStringField("      key",
+                     google_protobuf_Struct_FieldsEntry_key(entries[i]),
+                     fields);
+      // value
+      const google_protobuf_Value* value =
+          google_protobuf_Struct_FieldsEntry_value(entries[i]);
+      if (value != nullptr) {
+        std::string value_str;
+        if (google_protobuf_Value_has_string_value(value)) {
+          value_str = absl::StrCat(
+              "string_value: \"",
+              UpbStringToAbsl(google_protobuf_Value_string_value(value)), "\"");
+        } else if (google_protobuf_Value_has_null_value(value)) {
+          value_str = "null_value: NULL_VALUE";
+        } else if (google_protobuf_Value_has_number_value(value)) {
+          value_str = absl::StrCat("double_value: ",
+                                   google_protobuf_Value_number_value(value));
+        } else if (google_protobuf_Value_has_bool_value(value)) {
+          value_str = absl::StrCat("bool_value: ",
+                                   google_protobuf_Value_bool_value(value));
+        } else if (google_protobuf_Value_has_struct_value(value)) {
+          value_str = "struct_value: <not printed>";
+        } else if (google_protobuf_Value_has_list_value(value)) {
+          value_str = "list_value: <not printed>";
+        } else {
+          value_str = "<unknown>";
+        }
+        fields->emplace_back(absl::StrCat("      value { ", value_str, " }"));
+      }
+      fields->emplace_back("    }");
+    }
+    fields->emplace_back("  }");
+  }
+  // locality
+  const envoy_api_v2_core_Locality* locality =
+      envoy_api_v2_core_Node_locality(node);
+  if (locality != nullptr) {
+    fields->emplace_back("  locality {");
+    AddLocalityField(2, locality, fields);
+    fields->emplace_back("  }");
+  }
+  // build_version
+  AddStringField("  build_version", envoy_api_v2_core_Node_build_version(node),
+                 fields);
+  // user_agent_name
+  AddStringField("  user_agent_name",
+                 envoy_api_v2_core_Node_user_agent_name(node), fields);
+  // user_agent_version
+  AddStringField("  user_agent_version",
+                 envoy_api_v2_core_Node_user_agent_version(node), fields);
+  // client_features
+  size_t num_client_features;
+  const upb_strview* client_features =
+      envoy_api_v2_core_Node_client_features(node, &num_client_features);
+  for (size_t i = 0; i < num_client_features; ++i) {
+    AddStringField("  client_features", client_features[i], fields);
+  }
+  fields->emplace_back("}");
+}
+
+void MaybeLogDiscoveryRequest(XdsClient* client, TraceFlag* tracer,
+                              const envoy_api_v2_DiscoveryRequest* request) {
+  if (GRPC_TRACE_FLAG_ENABLED(*tracer) &&
+      gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
+    // TODO(roth): When we can upgrade upb, use upb textformat code to dump
+    // the raw proto instead of doing this manually.
+    std::vector<std::string> fields;
+    // version_info
+    AddStringField("version_info",
+                   envoy_api_v2_DiscoveryRequest_version_info(request),
+                   &fields);
+    // node
+    const envoy_api_v2_core_Node* node =
+        envoy_api_v2_DiscoveryRequest_node(request);
+    if (node != nullptr) AddNodeLogFields(node, &fields);
+    // resource_names
+    size_t num_resource_names;
+    const upb_strview* resource_names =
+        envoy_api_v2_DiscoveryRequest_resource_names(request,
+                                                     &num_resource_names);
+    for (size_t i = 0; i < num_resource_names; ++i) {
+      AddStringField("resource_names", resource_names[i], &fields);
+    }
+    // type_url
+    AddStringField("type_url", envoy_api_v2_DiscoveryRequest_type_url(request),
+                   &fields);
+    // response_nonce
+    AddStringField("response_nonce",
+                   envoy_api_v2_DiscoveryRequest_response_nonce(request),
+                   &fields);
+    // error_detail
+    const struct google_rpc_Status* error_detail =
+        envoy_api_v2_DiscoveryRequest_error_detail(request);
+    if (error_detail != nullptr) {
+      fields.emplace_back("error_detail {");
+      // code
+      int32_t code = google_rpc_Status_code(error_detail);
+      if (code != 0) fields.emplace_back(absl::StrCat("  code: ", code));
+      // message
+      AddStringField("  message", google_rpc_Status_message(error_detail),
+                     &fields);
+      fields.emplace_back("}");
+    }
+    gpr_log(GPR_DEBUG, "[xds_client %p] constructed ADS request: %s", client,
+            absl::StrJoin(fields, "\n").c_str());
+  }
+}
+
+grpc_slice SerializeDiscoveryRequest(upb_arena* arena,
+                                     envoy_api_v2_DiscoveryRequest* request) {
   size_t output_length;
-  char* output = envoy_api_v2_DiscoveryRequest_serialize(request, arena.ptr(),
-                                                         &output_length);
+  char* output =
+      envoy_api_v2_DiscoveryRequest_serialize(request, arena, &output_length);
   return grpc_slice_from_copied_buffer(output, output_length);
 }
 
+}  // namespace
+
+grpc_slice XdsApi::CreateUnsupportedTypeNackRequest(const std::string& type_url,
+                                                    const std::string& nonce,
+                                                    grpc_error* error) {
+  upb::Arena arena;
+  envoy_api_v2_DiscoveryRequest* request = CreateDiscoveryRequest(
+      arena.ptr(), type_url.c_str(), /*version=*/"", nonce, error);
+  MaybeLogDiscoveryRequest(client_, tracer_, request);
+  return SerializeDiscoveryRequest(arena.ptr(), request);
+}
+
+grpc_slice XdsApi::CreateLdsRequest(const std::string& server_name,
+                                    const std::string& version,
+                                    const std::string& nonce, grpc_error* error,
+                                    bool populate_node) {
+  upb::Arena arena;
+  envoy_api_v2_DiscoveryRequest* request =
+      CreateDiscoveryRequest(arena.ptr(), kLdsTypeUrl, version, nonce, error);
+  // Populate node.
+  if (populate_node) {
+    envoy_api_v2_core_Node* node_msg =
+        envoy_api_v2_DiscoveryRequest_mutable_node(request, arena.ptr());
+    PopulateNode(arena.ptr(), node_, build_version_, user_agent_name_, "",
+                 node_msg);
+  }
+  // Add resource_name.
+  envoy_api_v2_DiscoveryRequest_add_resource_names(
+      request, upb_strview_make(server_name.data(), server_name.size()),
+      arena.ptr());
+  MaybeLogDiscoveryRequest(client_, tracer_, request);
+  return SerializeDiscoveryRequest(arena.ptr(), request);
+}
+
+grpc_slice XdsApi::CreateRdsRequest(const std::string& route_config_name,
+                                    const std::string& version,
+                                    const std::string& nonce, grpc_error* error,
+                                    bool populate_node) {
+  upb::Arena arena;
+  envoy_api_v2_DiscoveryRequest* request =
+      CreateDiscoveryRequest(arena.ptr(), kRdsTypeUrl, version, nonce, error);
+  // Populate node.
+  if (populate_node) {
+    envoy_api_v2_core_Node* node_msg =
+        envoy_api_v2_DiscoveryRequest_mutable_node(request, arena.ptr());
+    PopulateNode(arena.ptr(), node_, build_version_, user_agent_name_, "",
+                 node_msg);
+  }
+  // Add resource_name.
+  envoy_api_v2_DiscoveryRequest_add_resource_names(
+      request,
+      upb_strview_make(route_config_name.data(), route_config_name.size()),
+      arena.ptr());
+  MaybeLogDiscoveryRequest(client_, tracer_, request);
+  return SerializeDiscoveryRequest(arena.ptr(), request);
+}
+
+grpc_slice XdsApi::CreateCdsRequest(const std::set<StringView>& cluster_names,
+                                    const std::string& version,
+                                    const std::string& nonce, grpc_error* error,
+                                    bool populate_node) {
+  upb::Arena arena;
+  envoy_api_v2_DiscoveryRequest* request =
+      CreateDiscoveryRequest(arena.ptr(), kCdsTypeUrl, version, nonce, error);
+  // Populate node.
+  if (populate_node) {
+    envoy_api_v2_core_Node* node_msg =
+        envoy_api_v2_DiscoveryRequest_mutable_node(request, arena.ptr());
+    PopulateNode(arena.ptr(), node_, build_version_, user_agent_name_, "",
+                 node_msg);
+  }
+  // Add resource_names.
+  for (const auto& cluster_name : cluster_names) {
+    envoy_api_v2_DiscoveryRequest_add_resource_names(
+        request, upb_strview_make(cluster_name.data(), cluster_name.size()),
+        arena.ptr());
+  }
+  MaybeLogDiscoveryRequest(client_, tracer_, request);
+  return SerializeDiscoveryRequest(arena.ptr(), request);
+}
+
+grpc_slice XdsApi::CreateEdsRequest(
+    const std::set<StringView>& eds_service_names, const std::string& version,
+    const std::string& nonce, grpc_error* error, bool populate_node) {
+  upb::Arena arena;
+  envoy_api_v2_DiscoveryRequest* request =
+      CreateDiscoveryRequest(arena.ptr(), kEdsTypeUrl, version, nonce, error);
+  // Populate node.
+  if (populate_node) {
+    envoy_api_v2_core_Node* node_msg =
+        envoy_api_v2_DiscoveryRequest_mutable_node(request, arena.ptr());
+    PopulateNode(arena.ptr(), node_, build_version_, user_agent_name_, "",
+                 node_msg);
+  }
+  // Add resource_names.
+  for (const auto& eds_service_name : eds_service_names) {
+    envoy_api_v2_DiscoveryRequest_add_resource_names(
+        request,
+        upb_strview_make(eds_service_name.data(), eds_service_name.size()),
+        arena.ptr());
+  }
+  MaybeLogDiscoveryRequest(client_, tracer_, request);
+  return SerializeDiscoveryRequest(arena.ptr(), request);
+}
+
 namespace {
 
+void MaybeLogDiscoveryResponse(XdsClient* client, TraceFlag* tracer,
+                               const envoy_api_v2_DiscoveryResponse* response) {
+  if (GRPC_TRACE_FLAG_ENABLED(*tracer) &&
+      gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
+    // TODO(roth): When we can upgrade upb, use upb textformat code to dump
+    // the raw proto instead of doing this manually.
+    std::vector<std::string> fields;
+    // version_info
+    AddStringField("version_info",
+                   envoy_api_v2_DiscoveryResponse_version_info(response),
+                   &fields);
+    // resources
+    size_t num_resources;
+    envoy_api_v2_DiscoveryResponse_resources(response, &num_resources);
+    fields.emplace_back(
+        absl::StrCat("resources: <", num_resources, " element(s)>"));
+    // type_url
+    AddStringField("type_url",
+                   envoy_api_v2_DiscoveryResponse_type_url(response), &fields);
+    // nonce
+    AddStringField("nonce", envoy_api_v2_DiscoveryResponse_nonce(response),
+                   &fields);
+    gpr_log(GPR_DEBUG, "[xds_client %p] received response: %s", client,
+            absl::StrJoin(fields, "\n").c_str());
+  }
+}
+
+void MaybeLogRouteConfiguration(
+    XdsClient* client, TraceFlag* tracer,
+    const envoy_api_v2_RouteConfiguration* route_config) {
+  if (GRPC_TRACE_FLAG_ENABLED(*tracer) &&
+      gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
+    // TODO(roth): When we can upgrade upb, use upb textformat code to dump
+    // the raw proto instead of doing this manually.
+    std::vector<std::string> fields;
+    // name
+    AddStringField("name", envoy_api_v2_RouteConfiguration_name(route_config),
+                   &fields);
+    // virtual_hosts
+    size_t num_virtual_hosts;
+    const envoy_api_v2_route_VirtualHost* const* virtual_hosts =
+        envoy_api_v2_RouteConfiguration_virtual_hosts(route_config,
+                                                      &num_virtual_hosts);
+    for (size_t i = 0; i < num_virtual_hosts; ++i) {
+      const auto* virtual_host = virtual_hosts[i];
+      fields.push_back("virtual_hosts {");
+      // name
+      AddStringField(
+          "  name", envoy_api_v2_route_VirtualHost_name(virtual_host), &fields);
+      // domains
+      size_t num_domains;
+      const upb_strview* const domains =
+          envoy_api_v2_route_VirtualHost_domains(virtual_host, &num_domains);
+      for (size_t j = 0; j < num_domains; ++j) {
+        AddStringField("  domains", domains[j], &fields);
+      }
+      // routes
+      size_t num_routes;
+      const envoy_api_v2_route_Route* const* routes =
+          envoy_api_v2_route_VirtualHost_routes(virtual_host, &num_routes);
+      for (size_t j = 0; j < num_routes; ++j) {
+        const auto* route = routes[j];
+        fields.push_back("  route {");
+        // name
+        AddStringField("    name", envoy_api_v2_route_Route_name(route),
+                       &fields);
+        // match
+        const envoy_api_v2_route_RouteMatch* match =
+            envoy_api_v2_route_Route_match(route);
+        if (match != nullptr) {
+          fields.emplace_back("    match {");
+          // path matching
+          if (envoy_api_v2_route_RouteMatch_has_prefix(match)) {
+            AddStringField("      prefix",
+                           envoy_api_v2_route_RouteMatch_prefix(match), &fields,
+                           /*add_if_empty=*/true);
+          } else if (envoy_api_v2_route_RouteMatch_has_path(match)) {
+            AddStringField("      path",
+                           envoy_api_v2_route_RouteMatch_path(match), &fields,
+                           /*add_if_empty=*/true);
+          } else if (envoy_api_v2_route_RouteMatch_has_regex(match)) {
+            AddStringField("      regex",
+                           envoy_api_v2_route_RouteMatch_regex(match), &fields,
+                           /*add_if_empty=*/true);
+          } else if (envoy_api_v2_route_RouteMatch_has_safe_regex(match)) {
+            fields.emplace_back("      safe_regex: <not printed>");
+          } else {
+            fields.emplace_back("      <unknown path matching type>");
+          }
+          // header matching
+          size_t num_headers;
+          envoy_api_v2_route_RouteMatch_headers(match, &num_headers);
+          if (num_headers > 0) {
+            fields.emplace_back(
+                absl::StrCat("      headers: <", num_headers, " element(s)>"));
+          }
+          fields.emplace_back("    }");
+        }
+        // action
+        if (envoy_api_v2_route_Route_has_route(route)) {
+          const envoy_api_v2_route_RouteAction* action =
+              envoy_api_v2_route_Route_route(route);
+          fields.emplace_back("    route {");
+          if (envoy_api_v2_route_RouteAction_has_cluster(action)) {
+            AddStringField("      cluster",
+                           envoy_api_v2_route_RouteAction_cluster(action),
+                           &fields);
+          } else if (envoy_api_v2_route_RouteAction_has_cluster_header(
+                         action)) {
+            AddStringField(
+                "      cluster_header",
+                envoy_api_v2_route_RouteAction_cluster_header(action), &fields);
+          } else if (envoy_api_v2_route_RouteAction_has_weighted_clusters(
+                         action)) {
+            fields.emplace_back("      weighted_clusters: <not printed>");
+          }
+          fields.emplace_back("    }");
+        } else if (envoy_api_v2_route_Route_has_redirect(route)) {
+          fields.emplace_back("    redirect: <not printed>");
+        } else if (envoy_api_v2_route_Route_has_direct_response(route)) {
+          fields.emplace_back("    direct_response: <not printed>");
+        } else if (envoy_api_v2_route_Route_has_filter_action(route)) {
+          fields.emplace_back("    filter_action: <not printed>");
+        }
+        fields.push_back("  }");
+      }
+      fields.push_back("}");
+    }
+    gpr_log(GPR_DEBUG, "[xds_client %p] RouteConfiguration: %s", client,
+            absl::StrJoin(fields, "\n").c_str());
+  }
+}
+
+void MaybeLogCluster(XdsClient* client, TraceFlag* tracer,
+                     const envoy_api_v2_Cluster* cluster) {
+  if (GRPC_TRACE_FLAG_ENABLED(*tracer) &&
+      gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
+    // TODO(roth): When we can upgrade upb, use upb textformat code to dump
+    // the raw proto instead of doing this manually.
+    std::vector<std::string> fields;
+    // name
+    AddStringField("name", envoy_api_v2_Cluster_name(cluster), &fields);
+    // type
+    if (envoy_api_v2_Cluster_has_type(cluster)) {
+      fields.emplace_back(
+          absl::StrCat("type: ", envoy_api_v2_Cluster_type(cluster)));
+    } else if (envoy_api_v2_Cluster_has_cluster_type(cluster)) {
+      fields.emplace_back("cluster_type: <not printed>");
+    } else {
+      fields.emplace_back("<unknown type>");
+    }
+    // eds_cluster_config
+    const envoy_api_v2_Cluster_EdsClusterConfig* eds_cluster_config =
+        envoy_api_v2_Cluster_eds_cluster_config(cluster);
+    if (eds_cluster_config != nullptr) {
+      fields.emplace_back("eds_cluster_config {");
+      // eds_config
+      const struct envoy_api_v2_core_ConfigSource* eds_config =
+          envoy_api_v2_Cluster_EdsClusterConfig_eds_config(eds_cluster_config);
+      if (eds_config != nullptr) {
+        if (envoy_api_v2_core_ConfigSource_has_ads(eds_config)) {
+          fields.emplace_back("  eds_config { ads {} }");
+        } else {
+          fields.emplace_back("  eds_config: <non-ADS type>");
+        }
+      }
+      // service_name
+      AddStringField("  service_name",
+                     envoy_api_v2_Cluster_EdsClusterConfig_service_name(
+                         eds_cluster_config),
+                     &fields);
+      fields.emplace_back("}");
+    }
+    // lb_policy
+    fields.emplace_back(
+        absl::StrCat("lb_policy: ", envoy_api_v2_Cluster_lb_policy(cluster)));
+    // lrs_server
+    const envoy_api_v2_core_ConfigSource* lrs_server =
+        envoy_api_v2_Cluster_lrs_server(cluster);
+    if (lrs_server != nullptr) {
+      if (envoy_api_v2_core_ConfigSource_has_self(lrs_server)) {
+        fields.emplace_back("lrs_server { self {} }");
+      } else {
+        fields.emplace_back("lrs_server: <non-self type>");
+      }
+    }
+    gpr_log(GPR_DEBUG, "[xds_client %p] Cluster: %s", client,
+            absl::StrJoin(fields, "\n").c_str());
+  }
+}
+
+void MaybeLogClusterLoadAssignment(
+    XdsClient* client, TraceFlag* tracer,
+    const envoy_api_v2_ClusterLoadAssignment* cla) {
+  if (GRPC_TRACE_FLAG_ENABLED(*tracer) &&
+      gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
+    // TODO(roth): When we can upgrade upb, use upb textformat code to dump
+    // the raw proto instead of doing this manually.
+    std::vector<std::string> fields;
+    // cluster_name
+    AddStringField("cluster_name",
+                   envoy_api_v2_ClusterLoadAssignment_cluster_name(cla),
+                   &fields);
+    // endpoints
+    size_t num_localities;
+    const struct envoy_api_v2_endpoint_LocalityLbEndpoints* const*
+        locality_endpoints =
+            envoy_api_v2_ClusterLoadAssignment_endpoints(cla, &num_localities);
+    for (size_t i = 0; i < num_localities; ++i) {
+      const auto* locality_endpoint = locality_endpoints[i];
+      fields.emplace_back("endpoints {");
+      // locality
+      const auto* locality =
+          envoy_api_v2_endpoint_LocalityLbEndpoints_locality(locality_endpoint);
+      if (locality != nullptr) {
+        fields.emplace_back("  locality {");
+        AddLocalityField(2, locality, &fields);
+        fields.emplace_back("  }");
+      }
+      // lb_endpoints
+      size_t num_lb_endpoints;
+      const envoy_api_v2_endpoint_LbEndpoint* const* lb_endpoints =
+          envoy_api_v2_endpoint_LocalityLbEndpoints_lb_endpoints(
+              locality_endpoint, &num_lb_endpoints);
+      for (size_t j = 0; j < num_lb_endpoints; ++j) {
+        const auto* lb_endpoint = lb_endpoints[j];
+        fields.emplace_back("  lb_endpoints {");
+        // health_status
+        uint32_t health_status =
+            envoy_api_v2_endpoint_LbEndpoint_health_status(lb_endpoint);
+        if (health_status > 0) {
+          fields.emplace_back(
+              absl::StrCat("    health_status: ", health_status));
+        }
+        // endpoint
+        const envoy_api_v2_endpoint_Endpoint* endpoint =
+            envoy_api_v2_endpoint_LbEndpoint_endpoint(lb_endpoint);
+        if (endpoint != nullptr) {
+          fields.emplace_back("    endpoint {");
+          // address
+          const auto* address =
+              envoy_api_v2_endpoint_Endpoint_address(endpoint);
+          if (address != nullptr) {
+            fields.emplace_back("      address {");
+            // socket_address
+            const auto* socket_address =
+                envoy_api_v2_core_Address_socket_address(address);
+            if (socket_address != nullptr) {
+              fields.emplace_back("        socket_address {");
+              // address
+              AddStringField(
+                  "          address",
+                  envoy_api_v2_core_SocketAddress_address(socket_address),
+                  &fields);
+              // port_value
+              if (envoy_api_v2_core_SocketAddress_has_port_value(
+                      socket_address)) {
+                fields.emplace_back(
+                    absl::StrCat("          port_value: ",
+                                 envoy_api_v2_core_SocketAddress_port_value(
+                                     socket_address)));
+              } else {
+                fields.emplace_back("        <non-numeric port>");
+              }
+              fields.emplace_back("        }");
+            } else {
+              fields.emplace_back("        <non-socket address>");
+            }
+            fields.emplace_back("      }");
+          }
+          fields.emplace_back("    }");
+        }
+        fields.emplace_back("  }");
+      }
+      // load_balancing_weight
+      const google_protobuf_UInt32Value* lb_weight =
+          envoy_api_v2_endpoint_LocalityLbEndpoints_load_balancing_weight(
+              locality_endpoint);
+      if (lb_weight != nullptr) {
+        fields.emplace_back(
+            absl::StrCat("  load_balancing_weight { value: ",
+                         google_protobuf_UInt32Value_value(lb_weight), " }"));
+      }
+      // priority
+      uint32_t priority =
+          envoy_api_v2_endpoint_LocalityLbEndpoints_priority(locality_endpoint);
+      if (priority > 0) {
+        fields.emplace_back(absl::StrCat("  priority: ", priority));
+      }
+      fields.emplace_back("}");
+    }
+    // policy
+    const envoy_api_v2_ClusterLoadAssignment_Policy* policy =
+        envoy_api_v2_ClusterLoadAssignment_policy(cla);
+    if (policy != nullptr) {
+      fields.emplace_back("policy {");
+      // drop_overloads
+      size_t num_drop_overloads;
+      const envoy_api_v2_ClusterLoadAssignment_Policy_DropOverload* const*
+          drop_overloads =
+              envoy_api_v2_ClusterLoadAssignment_Policy_drop_overloads(
+                  policy, &num_drop_overloads);
+      for (size_t i = 0; i < num_drop_overloads; ++i) {
+        auto* drop_overload = drop_overloads[i];
+        fields.emplace_back("  drop_overloads {");
+        // category
+        AddStringField(
+            "    category",
+            envoy_api_v2_ClusterLoadAssignment_Policy_DropOverload_category(
+                drop_overload),
+            &fields);
+        // drop_percentage
+        const auto* drop_percentage =
+            envoy_api_v2_ClusterLoadAssignment_Policy_DropOverload_drop_percentage(
+                drop_overload);
+        if (drop_percentage != nullptr) {
+          fields.emplace_back("    drop_percentage {");
+          fields.emplace_back(absl::StrCat(
+              "      numerator: ",
+              envoy_type_FractionalPercent_numerator(drop_percentage)));
+          fields.emplace_back(absl::StrCat(
+              "      denominator: ",
+              envoy_type_FractionalPercent_denominator(drop_percentage)));
+          fields.emplace_back("    }");
+        }
+        fields.emplace_back("  }");
+      }
+      // overprovisioning_factor
+      fields.emplace_back("}");
+    }
+    gpr_log(GPR_DEBUG, "[xds_client %p] ClusterLoadAssignment: %s", client,
+            absl::StrJoin(fields, "\n").c_str());
+  }
+}
+
+// Better match type has smaller value.
+enum MatchType {
+  EXACT_MATCH,
+  SUFFIX_MATCH,
+  PREFIX_MATCH,
+  UNIVERSE_MATCH,
+  INVALID_MATCH,
+};
+
+// Returns true if match succeeds.
+bool DomainMatch(MatchType match_type, std::string domain_pattern,
+                 std::string expected_host_name) {
+  // Normalize the args to lower-case. Domain matching is case-insensitive.
+  std::transform(domain_pattern.begin(), domain_pattern.end(),
+                 domain_pattern.begin(),
+                 [](unsigned char c) { return std::tolower(c); });
+  std::transform(expected_host_name.begin(), expected_host_name.end(),
+                 expected_host_name.begin(),
+                 [](unsigned char c) { return std::tolower(c); });
+  if (match_type == EXACT_MATCH) {
+    return domain_pattern == expected_host_name;
+  } else if (match_type == SUFFIX_MATCH) {
+    // Asterisk must match at least one char.
+    if (expected_host_name.size() < domain_pattern.size()) return false;
+    StringView pattern_suffix(domain_pattern.c_str() + 1);
+    StringView host_suffix(expected_host_name.c_str() +
+                           expected_host_name.size() - pattern_suffix.size());
+    return pattern_suffix == host_suffix;
+  } else if (match_type == PREFIX_MATCH) {
+    // Asterisk must match at least one char.
+    if (expected_host_name.size() < domain_pattern.size()) return false;
+    StringView pattern_prefix(domain_pattern.c_str(),
+                              domain_pattern.size() - 1);
+    StringView host_prefix(expected_host_name.c_str(), pattern_prefix.size());
+    return pattern_prefix == host_prefix;
+  } else {
+    return match_type == UNIVERSE_MATCH;
+  }
+}
+
+MatchType DomainPatternMatchType(const std::string& domain_pattern) {
+  if (domain_pattern.empty()) return INVALID_MATCH;
+  if (domain_pattern.find('*') == std::string::npos) return EXACT_MATCH;
+  if (domain_pattern == "*") return UNIVERSE_MATCH;
+  if (domain_pattern[0] == '*') return SUFFIX_MATCH;
+  if (domain_pattern[domain_pattern.size() - 1] == '*') return PREFIX_MATCH;
+  return INVALID_MATCH;
+}
+
+grpc_error* RouteConfigParse(
+    XdsClient* client, TraceFlag* tracer,
+    const envoy_api_v2_RouteConfiguration* route_config,
+    const std::string& expected_server_name, XdsApi::RdsUpdate* rds_update) {
+  MaybeLogRouteConfiguration(client, tracer, route_config);
+  // Get the virtual hosts.
+  size_t size;
+  const envoy_api_v2_route_VirtualHost* const* virtual_hosts =
+      envoy_api_v2_RouteConfiguration_virtual_hosts(route_config, &size);
+  // Find the best matched virtual host.
+  // The search order for 4 groups of domain patterns:
+  //   1. Exact match.
+  //   2. Suffix match (e.g., "*ABC").
+  //   3. Prefix match (e.g., "ABC*").
+  //   4. Universe match (i.e., "*").
+  // Within each group, longest match wins.
+  // If the same best matched domain pattern appears in multiple virtual hosts,
+  // the first matched virtual host wins.
+  const envoy_api_v2_route_VirtualHost* target_virtual_host = nullptr;
+  MatchType best_match_type = INVALID_MATCH;
+  size_t longest_match = 0;
+  // Check each domain pattern in each virtual host to determine the best
+  // matched virtual host.
+  for (size_t i = 0; i < size; ++i) {
+    size_t domain_size;
+    upb_strview const* domains =
+        envoy_api_v2_route_VirtualHost_domains(virtual_hosts[i], &domain_size);
+    for (size_t j = 0; j < domain_size; ++j) {
+      const std::string domain_pattern(domains[j].data, domains[j].size);
+      // Check the match type first. Skip the pattern if it's not better than
+      // current match.
+      const MatchType match_type = DomainPatternMatchType(domain_pattern);
+      if (match_type == INVALID_MATCH) {
+        return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Invalid domain pattern.");
+      }
+      if (match_type > best_match_type) continue;
+      if (match_type == best_match_type &&
+          domain_pattern.size() <= longest_match) {
+        continue;
+      }
+      // Skip if match fails.
+      if (!DomainMatch(match_type, domain_pattern, expected_server_name)) {
+        continue;
+      }
+      // Choose this match.
+      target_virtual_host = virtual_hosts[i];
+      best_match_type = match_type;
+      longest_match = domain_pattern.size();
+      if (best_match_type == EXACT_MATCH) break;
+    }
+    if (best_match_type == EXACT_MATCH) break;
+  }
+  if (target_virtual_host == nullptr) {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "No matched virtual host found in the route config.");
+  }
+  // Get the route list from the matched virtual host.
+  const envoy_api_v2_route_Route* const* routes =
+      envoy_api_v2_route_VirtualHost_routes(target_virtual_host, &size);
+  if (size < 1) {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "No route found in the virtual host.");
+  }
+  // Only look at the last one in the route list (the default route),
+  const envoy_api_v2_route_Route* route = routes[size - 1];
+  // Validate that the match field must have a prefix field which is an empty
+  // string.
+  const envoy_api_v2_route_RouteMatch* match =
+      envoy_api_v2_route_Route_match(route);
+  if (!envoy_api_v2_route_RouteMatch_has_prefix(match)) {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "No prefix field found in RouteMatch.");
+  }
+  const upb_strview prefix = envoy_api_v2_route_RouteMatch_prefix(match);
+  if (!upb_strview_eql(prefix, upb_strview_makez(""))) {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Prefix is not empty string.");
+  }
+  if (!envoy_api_v2_route_Route_has_route(route)) {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "No RouteAction found in route.");
+  }
+  const envoy_api_v2_route_RouteAction* route_action =
+      envoy_api_v2_route_Route_route(route);
+  // Get the cluster in the RouteAction.
+  if (!envoy_api_v2_route_RouteAction_has_cluster(route_action)) {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "No cluster found in RouteAction.");
+  }
+  const upb_strview cluster =
+      envoy_api_v2_route_RouteAction_cluster(route_action);
+  rds_update->cluster_name = std::string(cluster.data, cluster.size);
+  return GRPC_ERROR_NONE;
+}
+
+grpc_error* LdsResponseParse(XdsClient* client, TraceFlag* tracer,
+                             const envoy_api_v2_DiscoveryResponse* response,
+                             const std::string& expected_server_name,
+                             absl::optional<XdsApi::LdsUpdate>* lds_update,
+                             upb_arena* arena) {
+  // Get the resources from the response.
+  size_t size;
+  const google_protobuf_Any* const* resources =
+      envoy_api_v2_DiscoveryResponse_resources(response, &size);
+  for (size_t i = 0; i < size; ++i) {
+    // Check the type_url of the resource.
+    const upb_strview type_url = google_protobuf_Any_type_url(resources[i]);
+    if (!upb_strview_eql(type_url, upb_strview_makez(XdsApi::kLdsTypeUrl))) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Resource is not LDS.");
+    }
+    // Decode the listener.
+    const upb_strview encoded_listener =
+        google_protobuf_Any_value(resources[i]);
+    const envoy_api_v2_Listener* listener = envoy_api_v2_Listener_parse(
+        encoded_listener.data, encoded_listener.size, arena);
+    if (listener == nullptr) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Can't decode listener.");
+    }
+    // Check listener name. Ignore unexpected listeners.
+    const upb_strview name = envoy_api_v2_Listener_name(listener);
+    const upb_strview expected_name =
+        upb_strview_makez(expected_server_name.c_str());
+    if (!upb_strview_eql(name, expected_name)) continue;
+    // Get api_listener and decode it to http_connection_manager.
+    const envoy_config_listener_v2_ApiListener* api_listener =
+        envoy_api_v2_Listener_api_listener(listener);
+    if (api_listener == nullptr) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "Listener doesn't have ApiListener.");
+    }
+    const upb_strview encoded_api_listener = google_protobuf_Any_value(
+        envoy_config_listener_v2_ApiListener_api_listener(api_listener));
+    const envoy_config_filter_network_http_connection_manager_v2_HttpConnectionManager*
+        http_connection_manager =
+            envoy_config_filter_network_http_connection_manager_v2_HttpConnectionManager_parse(
+                encoded_api_listener.data, encoded_api_listener.size, arena);
+    // Found inlined route_config. Parse it to find the cluster_name.
+    if (envoy_config_filter_network_http_connection_manager_v2_HttpConnectionManager_has_route_config(
+            http_connection_manager)) {
+      const envoy_api_v2_RouteConfiguration* route_config =
+          envoy_config_filter_network_http_connection_manager_v2_HttpConnectionManager_route_config(
+              http_connection_manager);
+      XdsApi::RdsUpdate rds_update;
+      grpc_error* error = RouteConfigParse(client, tracer, route_config,
+                                           expected_server_name, &rds_update);
+      if (error != GRPC_ERROR_NONE) return error;
+      lds_update->emplace();
+      (*lds_update)->rds_update.emplace(std::move(rds_update));
+      return GRPC_ERROR_NONE;
+    }
+    // Validate that RDS must be used to get the route_config dynamically.
+    if (!envoy_config_filter_network_http_connection_manager_v2_HttpConnectionManager_has_rds(
+            http_connection_manager)) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "HttpConnectionManager neither has inlined route_config nor RDS.");
+    }
+    // Get the route_config_name.
+    const envoy_config_filter_network_http_connection_manager_v2_Rds* rds =
+        envoy_config_filter_network_http_connection_manager_v2_HttpConnectionManager_rds(
+            http_connection_manager);
+    const upb_strview route_config_name =
+        envoy_config_filter_network_http_connection_manager_v2_Rds_route_config_name(
+            rds);
+    lds_update->emplace();
+    (*lds_update)->route_config_name =
+        std::string(route_config_name.data, route_config_name.size);
+    return GRPC_ERROR_NONE;
+  }
+  return GRPC_ERROR_NONE;
+}
+
+grpc_error* RdsResponseParse(XdsClient* client, TraceFlag* tracer,
+                             const envoy_api_v2_DiscoveryResponse* response,
+                             const std::string& expected_server_name,
+                             const std::string& expected_route_config_name,
+                             absl::optional<XdsApi::RdsUpdate>* rds_update,
+                             upb_arena* arena) {
+  // Get the resources from the response.
+  size_t size;
+  const google_protobuf_Any* const* resources =
+      envoy_api_v2_DiscoveryResponse_resources(response, &size);
+  for (size_t i = 0; i < size; ++i) {
+    // Check the type_url of the resource.
+    const upb_strview type_url = google_protobuf_Any_type_url(resources[i]);
+    if (!upb_strview_eql(type_url, upb_strview_makez(XdsApi::kRdsTypeUrl))) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Resource is not RDS.");
+    }
+    // Decode the route_config.
+    const upb_strview encoded_route_config =
+        google_protobuf_Any_value(resources[i]);
+    const envoy_api_v2_RouteConfiguration* route_config =
+        envoy_api_v2_RouteConfiguration_parse(encoded_route_config.data,
+                                              encoded_route_config.size, arena);
+    if (route_config == nullptr) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Can't decode route_config.");
+    }
+    // Check route_config_name. Ignore unexpected route_config.
+    const upb_strview name = envoy_api_v2_RouteConfiguration_name(route_config);
+    const upb_strview expected_name =
+        upb_strview_makez(expected_route_config_name.c_str());
+    if (!upb_strview_eql(name, expected_name)) continue;
+    // Parse the route_config.
+    XdsApi::RdsUpdate local_rds_update;
+    grpc_error* error = RouteConfigParse(
+        client, tracer, route_config, expected_server_name, &local_rds_update);
+    if (error != GRPC_ERROR_NONE) return error;
+    rds_update->emplace(std::move(local_rds_update));
+    return GRPC_ERROR_NONE;
+  }
+  return GRPC_ERROR_NONE;
+}
+
+grpc_error* CdsResponseParse(XdsClient* client, TraceFlag* tracer,
+                             const envoy_api_v2_DiscoveryResponse* response,
+                             const std::set<StringView>& expected_cluster_names,
+                             XdsApi::CdsUpdateMap* cds_update_map,
+                             upb_arena* arena) {
+  // Get the resources from the response.
+  size_t size;
+  const google_protobuf_Any* const* resources =
+      envoy_api_v2_DiscoveryResponse_resources(response, &size);
+  // Parse all the resources in the CDS response.
+  for (size_t i = 0; i < size; ++i) {
+    XdsApi::CdsUpdate cds_update;
+    // Check the type_url of the resource.
+    const upb_strview type_url = google_protobuf_Any_type_url(resources[i]);
+    if (!upb_strview_eql(type_url, upb_strview_makez(XdsApi::kCdsTypeUrl))) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Resource is not CDS.");
+    }
+    // Decode the cluster.
+    const upb_strview encoded_cluster = google_protobuf_Any_value(resources[i]);
+    const envoy_api_v2_Cluster* cluster = envoy_api_v2_Cluster_parse(
+        encoded_cluster.data, encoded_cluster.size, arena);
+    if (cluster == nullptr) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Can't decode cluster.");
+    }
+    MaybeLogCluster(client, tracer, cluster);
+    // Ignore unexpected cluster names.
+    upb_strview cluster_name = envoy_api_v2_Cluster_name(cluster);
+    StringView cluster_name_strview(cluster_name.data, cluster_name.size);
+    if (expected_cluster_names.find(cluster_name_strview) ==
+        expected_cluster_names.end()) {
+      continue;
+    }
+    // Check the cluster_discovery_type.
+    if (!envoy_api_v2_Cluster_has_type(cluster)) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("DiscoveryType not found.");
+    }
+    if (envoy_api_v2_Cluster_type(cluster) != envoy_api_v2_Cluster_EDS) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("DiscoveryType is not EDS.");
+    }
+    // Check the EDS config source.
+    const envoy_api_v2_Cluster_EdsClusterConfig* eds_cluster_config =
+        envoy_api_v2_Cluster_eds_cluster_config(cluster);
+    const envoy_api_v2_core_ConfigSource* eds_config =
+        envoy_api_v2_Cluster_EdsClusterConfig_eds_config(eds_cluster_config);
+    if (!envoy_api_v2_core_ConfigSource_has_ads(eds_config)) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("ConfigSource is not ADS.");
+    }
+    // Record EDS service_name (if any).
+    upb_strview service_name =
+        envoy_api_v2_Cluster_EdsClusterConfig_service_name(eds_cluster_config);
+    if (service_name.size != 0) {
+      cds_update.eds_service_name =
+          std::string(service_name.data, service_name.size);
+    }
+    // Check the LB policy.
+    if (envoy_api_v2_Cluster_lb_policy(cluster) !=
+        envoy_api_v2_Cluster_ROUND_ROBIN) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "LB policy is not ROUND_ROBIN.");
+    }
+    // Record LRS server name (if any).
+    const envoy_api_v2_core_ConfigSource* lrs_server =
+        envoy_api_v2_Cluster_lrs_server(cluster);
+    if (lrs_server != nullptr) {
+      if (!envoy_api_v2_core_ConfigSource_has_self(lrs_server)) {
+        return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "ConfigSource is not self.");
+      }
+      cds_update.lrs_load_reporting_server_name.emplace("");
+    }
+    cds_update_map->emplace(std::string(cluster_name.data, cluster_name.size),
+                            std::move(cds_update));
+  }
+  return GRPC_ERROR_NONE;
+}
+
 grpc_error* ServerAddressParseAndAppend(
     const envoy_api_v2_endpoint_LbEndpoint* lb_endpoint,
     ServerAddressList* list) {
@@ -257,20 +1270,9 @@ grpc_error* ServerAddressParseAndAppend(
   return GRPC_ERROR_NONE;
 }
 
-namespace {
-
-grpc_core::UniquePtr<char> StringCopy(const upb_strview& strview) {
-  char* str = static_cast<char*>(gpr_malloc(strview.size + 1));
-  memcpy(str, strview.data, strview.size);
-  str[strview.size] = '\0';
-  return grpc_core::UniquePtr<char>(str);
-}
-
-}  // namespace
-
 grpc_error* LocalityParse(
     const envoy_api_v2_endpoint_LocalityLbEndpoints* locality_lb_endpoints,
-    XdsPriorityListUpdate::LocalityMap::Locality* output_locality) {
+    XdsApi::PriorityListUpdate::LocalityMap::Locality* output_locality) {
   // Parse LB weight.
   const google_protobuf_UInt32Value* lb_weight =
       envoy_api_v2_endpoint_LocalityLbEndpoints_load_balancing_weight(
@@ -284,10 +1286,12 @@ grpc_error* LocalityParse(
   // Parse locality name.
   const envoy_api_v2_core_Locality* locality =
       envoy_api_v2_endpoint_LocalityLbEndpoints_locality(locality_lb_endpoints);
+  upb_strview region = envoy_api_v2_core_Locality_region(locality);
+  upb_strview zone = envoy_api_v2_core_Locality_region(locality);
+  upb_strview sub_zone = envoy_api_v2_core_Locality_sub_zone(locality);
   output_locality->name = MakeRefCounted<XdsLocalityName>(
-      StringCopy(envoy_api_v2_core_Locality_region(locality)),
-      StringCopy(envoy_api_v2_core_Locality_zone(locality)),
-      StringCopy(envoy_api_v2_core_Locality_sub_zone(locality)));
+      std::string(region.data, region.size), std::string(zone.data, zone.size),
+      std::string(sub_zone.data, sub_zone.size));
   // Parse the addresses.
   size_t size;
   const envoy_api_v2_endpoint_LbEndpoint* const* lb_endpoints =
@@ -306,7 +1310,7 @@ grpc_error* LocalityParse(
 
 grpc_error* DropParseAndAppend(
     const envoy_api_v2_ClusterLoadAssignment_Policy_DropOverload* drop_overload,
-    XdsDropConfig* drop_config, bool* drop_all) {
+    XdsApi::DropConfig* drop_config) {
   // Get the category.
   upb_strview category =
       envoy_api_v2_ClusterLoadAssignment_Policy_DropOverload_category(
@@ -337,84 +1341,270 @@ grpc_error* DropParseAndAppend(
   }
   // Cap numerator to 1000000.
   numerator = GPR_MIN(numerator, 1000000);
-  if (numerator == 1000000) *drop_all = true;
-  drop_config->AddCategory(StringCopy(category), numerator);
+  drop_config->AddCategory(std::string(category.data, category.size),
+                           numerator);
+  return GRPC_ERROR_NONE;
+}
+
+grpc_error* EdsResponseParse(
+    XdsClient* client, TraceFlag* tracer,
+    const envoy_api_v2_DiscoveryResponse* response,
+    const std::set<StringView>& expected_eds_service_names,
+    XdsApi::EdsUpdateMap* eds_update_map, upb_arena* arena) {
+  // Get the resources from the response.
+  size_t size;
+  const google_protobuf_Any* const* resources =
+      envoy_api_v2_DiscoveryResponse_resources(response, &size);
+  for (size_t i = 0; i < size; ++i) {
+    XdsApi::EdsUpdate eds_update;
+    // Check the type_url of the resource.
+    upb_strview type_url = google_protobuf_Any_type_url(resources[i]);
+    if (!upb_strview_eql(type_url, upb_strview_makez(XdsApi::kEdsTypeUrl))) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Resource is not EDS.");
+    }
+    // Get the cluster_load_assignment.
+    upb_strview encoded_cluster_load_assignment =
+        google_protobuf_Any_value(resources[i]);
+    envoy_api_v2_ClusterLoadAssignment* cluster_load_assignment =
+        envoy_api_v2_ClusterLoadAssignment_parse(
+            encoded_cluster_load_assignment.data,
+            encoded_cluster_load_assignment.size, arena);
+    if (cluster_load_assignment == nullptr) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "Can't parse cluster_load_assignment.");
+    }
+    MaybeLogClusterLoadAssignment(client, tracer, cluster_load_assignment);
+    // Check the cluster name (which actually means eds_service_name). Ignore
+    // unexpected names.
+    upb_strview cluster_name = envoy_api_v2_ClusterLoadAssignment_cluster_name(
+        cluster_load_assignment);
+    StringView cluster_name_strview(cluster_name.data, cluster_name.size);
+    if (expected_eds_service_names.find(cluster_name_strview) ==
+        expected_eds_service_names.end()) {
+      continue;
+    }
+    // Get the endpoints.
+    size_t locality_size;
+    const envoy_api_v2_endpoint_LocalityLbEndpoints* const* endpoints =
+        envoy_api_v2_ClusterLoadAssignment_endpoints(cluster_load_assignment,
+                                                     &locality_size);
+    for (size_t j = 0; j < locality_size; ++j) {
+      XdsApi::PriorityListUpdate::LocalityMap::Locality locality;
+      grpc_error* error = LocalityParse(endpoints[j], &locality);
+      if (error != GRPC_ERROR_NONE) return error;
+      // Filter out locality with weight 0.
+      if (locality.lb_weight == 0) continue;
+      eds_update.priority_list_update.Add(locality);
+    }
+    for (uint32_t priority = 0;
+         priority < eds_update.priority_list_update.size(); ++priority) {
+      auto* locality_map = eds_update.priority_list_update.Find(priority);
+      if (locality_map == nullptr || locality_map->size() == 0) {
+        return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "EDS update includes sparse priority list");
+      }
+    }
+    // Get the drop config.
+    eds_update.drop_config = MakeRefCounted<XdsApi::DropConfig>();
+    const envoy_api_v2_ClusterLoadAssignment_Policy* policy =
+        envoy_api_v2_ClusterLoadAssignment_policy(cluster_load_assignment);
+    if (policy != nullptr) {
+      size_t drop_size;
+      const envoy_api_v2_ClusterLoadAssignment_Policy_DropOverload* const*
+          drop_overload =
+              envoy_api_v2_ClusterLoadAssignment_Policy_drop_overloads(
+                  policy, &drop_size);
+      for (size_t j = 0; j < drop_size; ++j) {
+        grpc_error* error =
+            DropParseAndAppend(drop_overload[j], eds_update.drop_config.get());
+        if (error != GRPC_ERROR_NONE) return error;
+      }
+    }
+    // Validate the update content.
+    if (eds_update.priority_list_update.empty() &&
+        !eds_update.drop_config->drop_all()) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "EDS response doesn't contain any valid "
+          "locality but doesn't require to drop all calls.");
+    }
+    eds_update_map->emplace(std::string(cluster_name.data, cluster_name.size),
+                            std::move(eds_update));
+  }
   return GRPC_ERROR_NONE;
 }
 
 }  // namespace
 
-grpc_error* XdsEdsResponseDecodeAndParse(const grpc_slice& encoded_response,
-                                         EdsUpdate* update) {
+grpc_error* XdsApi::ParseAdsResponse(
+    const grpc_slice& encoded_response, const std::string& expected_server_name,
+    const std::string& expected_route_config_name,
+    const std::set<StringView>& expected_cluster_names,
+    const std::set<StringView>& expected_eds_service_names,
+    absl::optional<LdsUpdate>* lds_update,
+    absl::optional<RdsUpdate>* rds_update, CdsUpdateMap* cds_update_map,
+    EdsUpdateMap* eds_update_map, std::string* version, std::string* nonce,
+    std::string* type_url) {
   upb::Arena arena;
   // Decode the response.
   const envoy_api_v2_DiscoveryResponse* response =
       envoy_api_v2_DiscoveryResponse_parse(
           reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(encoded_response)),
           GRPC_SLICE_LENGTH(encoded_response), arena.ptr());
-  // Parse the response.
+  // If decoding fails, output an empty type_url and return.
   if (response == nullptr) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("No response found.");
-  }
-  // Check the type_url of the response.
-  upb_strview type_url = envoy_api_v2_DiscoveryResponse_type_url(response);
-  upb_strview expected_type_url = upb_strview_makez(kEdsTypeUrl);
-  if (!upb_strview_eql(type_url, expected_type_url)) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Resource is not EDS.");
+    *type_url = "";
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "Can't decode the whole response.");
   }
-  // Get the resources from the response.
-  size_t size;
-  const google_protobuf_Any* const* resources =
-      envoy_api_v2_DiscoveryResponse_resources(response, &size);
-  if (size < 1) {
+  MaybeLogDiscoveryResponse(client_, tracer_, response);
+  // Record the type_url, the version_info, and the nonce of the response.
+  upb_strview type_url_strview =
+      envoy_api_v2_DiscoveryResponse_type_url(response);
+  *type_url = std::string(type_url_strview.data, type_url_strview.size);
+  upb_strview version_info =
+      envoy_api_v2_DiscoveryResponse_version_info(response);
+  *version = std::string(version_info.data, version_info.size);
+  upb_strview nonce_strview = envoy_api_v2_DiscoveryResponse_nonce(response);
+  *nonce = std::string(nonce_strview.data, nonce_strview.size);
+  // Parse the response according to the resource type.
+  if (*type_url == kLdsTypeUrl) {
+    return LdsResponseParse(client_, tracer_, response, expected_server_name,
+                            lds_update, arena.ptr());
+  } else if (*type_url == kRdsTypeUrl) {
+    return RdsResponseParse(client_, tracer_, response, expected_server_name,
+                            expected_route_config_name, rds_update,
+                            arena.ptr());
+  } else if (*type_url == kCdsTypeUrl) {
+    return CdsResponseParse(client_, tracer_, response, expected_cluster_names,
+                            cds_update_map, arena.ptr());
+  } else if (*type_url == kEdsTypeUrl) {
+    return EdsResponseParse(client_, tracer_, response,
+                            expected_eds_service_names, eds_update_map,
+                            arena.ptr());
+  } else {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "EDS response contains 0 resource.");
-  }
-  // Check the type_url of the resource.
-  type_url = google_protobuf_Any_type_url(resources[0]);
-  if (!upb_strview_eql(type_url, expected_type_url)) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Resource is not EDS.");
-  }
-  // Get the cluster_load_assignment.
-  upb_strview encoded_cluster_load_assignment =
-      google_protobuf_Any_value(resources[0]);
-  envoy_api_v2_ClusterLoadAssignment* cluster_load_assignment =
-      envoy_api_v2_ClusterLoadAssignment_parse(
-          encoded_cluster_load_assignment.data,
-          encoded_cluster_load_assignment.size, arena.ptr());
-  // Get the endpoints.
-  const envoy_api_v2_endpoint_LocalityLbEndpoints* const* endpoints =
-      envoy_api_v2_ClusterLoadAssignment_endpoints(cluster_load_assignment,
-                                                   &size);
-  for (size_t i = 0; i < size; ++i) {
-    XdsPriorityListUpdate::LocalityMap::Locality locality;
-    grpc_error* error = LocalityParse(endpoints[i], &locality);
-    if (error != GRPC_ERROR_NONE) return error;
-    // Filter out locality with weight 0.
-    if (locality.lb_weight == 0) continue;
-    update->priority_list_update.Add(locality);
-  }
-  // Get the drop config.
-  update->drop_config = MakeRefCounted<XdsDropConfig>();
-  const envoy_api_v2_ClusterLoadAssignment_Policy* policy =
-      envoy_api_v2_ClusterLoadAssignment_policy(cluster_load_assignment);
-  if (policy != nullptr) {
-    const envoy_api_v2_ClusterLoadAssignment_Policy_DropOverload* const*
-        drop_overload =
-            envoy_api_v2_ClusterLoadAssignment_Policy_drop_overloads(policy,
-                                                                     &size);
-    for (size_t i = 0; i < size; ++i) {
-      grpc_error* error = DropParseAndAppend(
-          drop_overload[i], update->drop_config.get(), &update->drop_all);
-      if (error != GRPC_ERROR_NONE) return error;
-    }
+        "Unsupported ADS resource type.");
   }
-  return GRPC_ERROR_NONE;
 }
 
 namespace {
 
-grpc_slice LrsRequestEncode(
+void MaybeLogLrsRequest(
+    XdsClient* client, TraceFlag* tracer,
+    const envoy_service_load_stats_v2_LoadStatsRequest* request) {
+  if (GRPC_TRACE_FLAG_ENABLED(*tracer) &&
+      gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
+    // TODO(roth): When we can upgrade upb, use upb textformat code to dump
+    // the raw proto instead of doing this manually.
+    std::vector<std::string> fields;
+    // node
+    const auto* node =
+        envoy_service_load_stats_v2_LoadStatsRequest_node(request);
+    if (node != nullptr) {
+      AddNodeLogFields(node, &fields);
+    }
+    // cluster_stats
+    size_t num_cluster_stats;
+    const struct envoy_api_v2_endpoint_ClusterStats* const* cluster_stats =
+        envoy_service_load_stats_v2_LoadStatsRequest_cluster_stats(
+            request, &num_cluster_stats);
+    for (size_t i = 0; i < num_cluster_stats; ++i) {
+      const auto* cluster_stat = cluster_stats[i];
+      fields.emplace_back("cluster_stats {");
+      // cluster_name
+      AddStringField(
+          "  cluster_name",
+          envoy_api_v2_endpoint_ClusterStats_cluster_name(cluster_stat),
+          &fields);
+      // cluster_service_name
+      AddStringField(
+          "  cluster_service_name",
+          envoy_api_v2_endpoint_ClusterStats_cluster_service_name(cluster_stat),
+          &fields);
+      // upstream_locality_stats
+      size_t num_stats;
+      const envoy_api_v2_endpoint_UpstreamLocalityStats* const* stats =
+          envoy_api_v2_endpoint_ClusterStats_upstream_locality_stats(
+              cluster_stat, &num_stats);
+      for (size_t j = 0; j < num_stats; ++j) {
+        const auto* stat = stats[j];
+        fields.emplace_back("  upstream_locality_stats {");
+        // locality
+        const auto* locality =
+            envoy_api_v2_endpoint_UpstreamLocalityStats_locality(stat);
+        if (locality != nullptr) {
+          fields.emplace_back("    locality {");
+          AddLocalityField(3, locality, &fields);
+          fields.emplace_back("    }");
+        }
+        // total_successful_requests
+        fields.emplace_back(absl::StrCat(
+            "    total_successful_requests: ",
+            envoy_api_v2_endpoint_UpstreamLocalityStats_total_successful_requests(
+                stat)));
+        // total_requests_in_progress
+        fields.emplace_back(absl::StrCat(
+            "    total_requests_in_progress: ",
+            envoy_api_v2_endpoint_UpstreamLocalityStats_total_requests_in_progress(
+                stat)));
+        // total_error_requests
+        fields.emplace_back(absl::StrCat(
+            "    total_error_requests: ",
+            envoy_api_v2_endpoint_UpstreamLocalityStats_total_error_requests(
+                stat)));
+        // total_issued_requests
+        fields.emplace_back(absl::StrCat(
+            "    total_issued_requests: ",
+            envoy_api_v2_endpoint_UpstreamLocalityStats_total_issued_requests(
+                stat)));
+        fields.emplace_back("  }");
+      }
+      // total_dropped_requests
+      fields.emplace_back(absl::StrCat(
+          "  total_dropped_requests: ",
+          envoy_api_v2_endpoint_ClusterStats_total_dropped_requests(
+              cluster_stat)));
+      // dropped_requests
+      size_t num_drops;
+      const envoy_api_v2_endpoint_ClusterStats_DroppedRequests* const* drops =
+          envoy_api_v2_endpoint_ClusterStats_dropped_requests(cluster_stat,
+                                                              &num_drops);
+      for (size_t j = 0; j < num_drops; ++j) {
+        const auto* drop = drops[j];
+        fields.emplace_back("  dropped_requests {");
+        // category
+        AddStringField(
+            "    category",
+            envoy_api_v2_endpoint_ClusterStats_DroppedRequests_category(drop),
+            &fields);
+        // dropped_count
+        fields.emplace_back(absl::StrCat(
+            "    dropped_count: ",
+            envoy_api_v2_endpoint_ClusterStats_DroppedRequests_dropped_count(
+                drop)));
+        fields.emplace_back("  }");
+      }
+      // load_report_interval
+      const auto* load_report_interval =
+          envoy_api_v2_endpoint_ClusterStats_load_report_interval(cluster_stat);
+      if (load_report_interval != nullptr) {
+        fields.emplace_back("  load_report_interval {");
+        fields.emplace_back(absl::StrCat(
+            "    seconds: ",
+            google_protobuf_Duration_seconds(load_report_interval)));
+        fields.emplace_back(
+            absl::StrCat("    nanos: ",
+                         google_protobuf_Duration_nanos(load_report_interval)));
+        fields.emplace_back("  }");
+      }
+      fields.emplace_back("}");
+    }
+    gpr_log(GPR_DEBUG, "[xds_client %p] constructed LRS request: %s", client,
+            absl::StrJoin(fields, "\n").c_str());
+  }
+}
+
+grpc_slice SerializeLrsRequest(
     const envoy_service_load_stats_v2_LoadStatsRequest* request,
     upb_arena* arena) {
   size_t output_length;
@@ -425,9 +1615,7 @@ grpc_slice LrsRequestEncode(
 
 }  // namespace
 
-grpc_slice XdsLrsRequestCreateAndEncode(const char* server_name,
-                                        const XdsBootstrap::Node* node,
-                                        const char* build_version) {
+grpc_slice XdsApi::CreateLrsInitialRequest(const std::string& server_name) {
   upb::Arena arena;
   // Create a request.
   envoy_service_load_stats_v2_LoadStatsRequest* request =
@@ -436,33 +1624,35 @@ grpc_slice XdsLrsRequestCreateAndEncode(const char* server_name,
   envoy_api_v2_core_Node* node_msg =
       envoy_service_load_stats_v2_LoadStatsRequest_mutable_node(request,
                                                                 arena.ptr());
-  PopulateNode(arena.ptr(), node, build_version, node_msg);
-  // Add cluster stats. There is only one because we only use one server name in
-  // one channel.
-  envoy_api_v2_endpoint_ClusterStats* cluster_stats =
-      envoy_service_load_stats_v2_LoadStatsRequest_add_cluster_stats(
-          request, arena.ptr());
-  // Set the cluster name.
-  envoy_api_v2_endpoint_ClusterStats_set_cluster_name(
-      cluster_stats, upb_strview_makez(server_name));
-  return LrsRequestEncode(request, arena.ptr());
+  PopulateNode(arena.ptr(), node_, build_version_, user_agent_name_,
+               server_name, node_msg);
+  MaybeLogLrsRequest(client_, tracer_, request);
+  return SerializeLrsRequest(request, arena.ptr());
 }
 
 namespace {
 
-void LocalityStatsPopulate(
-    envoy_api_v2_endpoint_UpstreamLocalityStats* output,
-    std::pair<const RefCountedPtr<XdsLocalityName>,
-              XdsClientStats::LocalityStats::Snapshot>& input,
-    upb_arena* arena) {
-  // Set sub_zone.
+void LocalityStatsPopulate(envoy_api_v2_endpoint_UpstreamLocalityStats* output,
+                           const XdsLocalityName& locality_name,
+                           const XdsClusterLocalityStats::Snapshot& snapshot,
+                           upb_arena* arena) {
+  // Set locality.
   envoy_api_v2_core_Locality* locality =
       envoy_api_v2_endpoint_UpstreamLocalityStats_mutable_locality(output,
                                                                    arena);
-  envoy_api_v2_core_Locality_set_sub_zone(
-      locality, upb_strview_makez(input.first->sub_zone()));
+  if (!locality_name.region().empty()) {
+    envoy_api_v2_core_Locality_set_region(
+        locality, upb_strview_makez(locality_name.region().c_str()));
+  }
+  if (!locality_name.zone().empty()) {
+    envoy_api_v2_core_Locality_set_zone(
+        locality, upb_strview_makez(locality_name.zone().c_str()));
+  }
+  if (!locality_name.sub_zone().empty()) {
+    envoy_api_v2_core_Locality_set_sub_zone(
+        locality, upb_strview_makez(locality_name.sub_zone().c_str()));
+  }
   // Set total counts.
-  XdsClientStats::LocalityStats::Snapshot& snapshot = input.second;
   envoy_api_v2_endpoint_UpstreamLocalityStats_set_total_successful_requests(
       output, snapshot.total_successful_requests);
   envoy_api_v2_endpoint_UpstreamLocalityStats_set_total_requests_in_progress(
@@ -471,16 +1661,15 @@ void LocalityStatsPopulate(
       output, snapshot.total_error_requests);
   envoy_api_v2_endpoint_UpstreamLocalityStats_set_total_issued_requests(
       output, snapshot.total_issued_requests);
-  // Add load metric stats.
-  for (auto& p : snapshot.load_metric_stats) {
-    const char* metric_name = p.first.get();
-    const XdsClientStats::LocalityStats::LoadMetric::Snapshot& metric_value =
-        p.second;
+  // Add backend metrics.
+  for (const auto& p : snapshot.backend_metrics) {
+    const std::string& metric_name = p.first;
+    const XdsClusterLocalityStats::BackendMetric& metric_value = p.second;
     envoy_api_v2_endpoint_EndpointLoadMetricStats* load_metric =
         envoy_api_v2_endpoint_UpstreamLocalityStats_add_load_metric_stats(
             output, arena);
     envoy_api_v2_endpoint_EndpointLoadMetricStats_set_metric_name(
-        load_metric, upb_strview_makez(metric_name));
+        load_metric, upb_strview_make(metric_name.data(), metric_name.size()));
     envoy_api_v2_endpoint_EndpointLoadMetricStats_set_num_requests_finished_with_metric(
         load_metric, metric_value.num_requests_finished_with_metric);
     envoy_api_v2_endpoint_EndpointLoadMetricStats_set_total_metric_value(
@@ -490,62 +1679,73 @@ void LocalityStatsPopulate(
 
 }  // namespace
 
-grpc_slice XdsLrsRequestCreateAndEncode(const char* server_name,
-                                        XdsClientStats* client_stats) {
+grpc_slice XdsApi::CreateLrsRequest(
+    ClusterLoadReportMap cluster_load_report_map) {
   upb::Arena arena;
-  XdsClientStats::Snapshot snapshot = client_stats->GetSnapshotAndReset();
-  // Prune unused locality stats.
-  client_stats->PruneLocalityStats();
-  // When all the counts are zero, return empty slice.
-  if (snapshot.IsAllZero()) return grpc_empty_slice();
   // Create a request.
   envoy_service_load_stats_v2_LoadStatsRequest* request =
       envoy_service_load_stats_v2_LoadStatsRequest_new(arena.ptr());
-  // Add cluster stats. There is only one because we only use one server name in
-  // one channel.
-  envoy_api_v2_endpoint_ClusterStats* cluster_stats =
-      envoy_service_load_stats_v2_LoadStatsRequest_add_cluster_stats(
-          request, arena.ptr());
-  // Set the cluster name.
-  envoy_api_v2_endpoint_ClusterStats_set_cluster_name(
-      cluster_stats, upb_strview_makez(server_name));
-  // Add locality stats.
-  for (auto& p : snapshot.upstream_locality_stats) {
-    envoy_api_v2_endpoint_UpstreamLocalityStats* locality_stats =
-        envoy_api_v2_endpoint_ClusterStats_add_upstream_locality_stats(
+  for (auto& p : cluster_load_report_map) {
+    const std::string& cluster_name = p.first.first;
+    const std::string& eds_service_name = p.first.second;
+    const ClusterLoadReport& load_report = p.second;
+    // Add cluster stats.
+    envoy_api_v2_endpoint_ClusterStats* cluster_stats =
+        envoy_service_load_stats_v2_LoadStatsRequest_add_cluster_stats(
+            request, arena.ptr());
+    // Set the cluster name.
+    envoy_api_v2_endpoint_ClusterStats_set_cluster_name(
+        cluster_stats,
+        upb_strview_make(cluster_name.data(), cluster_name.size()));
+    // Set EDS service name, if non-empty.
+    if (!eds_service_name.empty()) {
+      envoy_api_v2_endpoint_ClusterStats_set_cluster_service_name(
+          cluster_stats,
+          upb_strview_make(eds_service_name.data(), eds_service_name.size()));
+    }
+    // Add locality stats.
+    for (const auto& p : load_report.locality_stats) {
+      const XdsLocalityName& locality_name = *p.first;
+      const auto& snapshot = p.second;
+      envoy_api_v2_endpoint_UpstreamLocalityStats* locality_stats =
+          envoy_api_v2_endpoint_ClusterStats_add_upstream_locality_stats(
+              cluster_stats, arena.ptr());
+      LocalityStatsPopulate(locality_stats, locality_name, snapshot,
+                            arena.ptr());
+    }
+    // Add dropped requests.
+    uint64_t total_dropped_requests = 0;
+    for (const auto& p : load_report.dropped_requests) {
+      const char* category = p.first.c_str();
+      const uint64_t count = p.second;
+      envoy_api_v2_endpoint_ClusterStats_DroppedRequests* dropped_requests =
+          envoy_api_v2_endpoint_ClusterStats_add_dropped_requests(cluster_stats,
+                                                                  arena.ptr());
+      envoy_api_v2_endpoint_ClusterStats_DroppedRequests_set_category(
+          dropped_requests, upb_strview_makez(category));
+      envoy_api_v2_endpoint_ClusterStats_DroppedRequests_set_dropped_count(
+          dropped_requests, count);
+      total_dropped_requests += count;
+    }
+    // Set total dropped requests.
+    envoy_api_v2_endpoint_ClusterStats_set_total_dropped_requests(
+        cluster_stats, total_dropped_requests);
+    // Set real load report interval.
+    gpr_timespec timespec =
+        grpc_millis_to_timespec(load_report.load_report_interval, GPR_TIMESPAN);
+    google_protobuf_Duration* load_report_interval =
+        envoy_api_v2_endpoint_ClusterStats_mutable_load_report_interval(
             cluster_stats, arena.ptr());
-    LocalityStatsPopulate(locality_stats, p, arena.ptr());
-  }
-  // Add dropped requests.
-  for (auto& p : snapshot.dropped_requests) {
-    const char* category = p.first.get();
-    const uint64_t count = p.second;
-    envoy_api_v2_endpoint_ClusterStats_DroppedRequests* dropped_requests =
-        envoy_api_v2_endpoint_ClusterStats_add_dropped_requests(cluster_stats,
-                                                                arena.ptr());
-    envoy_api_v2_endpoint_ClusterStats_DroppedRequests_set_category(
-        dropped_requests, upb_strview_makez(category));
-    envoy_api_v2_endpoint_ClusterStats_DroppedRequests_set_dropped_count(
-        dropped_requests, count);
-  }
-  // Set total dropped requests.
-  envoy_api_v2_endpoint_ClusterStats_set_total_dropped_requests(
-      cluster_stats, snapshot.total_dropped_requests);
-  // Set real load report interval.
-  gpr_timespec timespec =
-      grpc_millis_to_timespec(snapshot.load_report_interval, GPR_TIMESPAN);
-  google_protobuf_Duration* load_report_interval =
-      envoy_api_v2_endpoint_ClusterStats_mutable_load_report_interval(
-          cluster_stats, arena.ptr());
-  google_protobuf_Duration_set_seconds(load_report_interval, timespec.tv_sec);
-  google_protobuf_Duration_set_nanos(load_report_interval, timespec.tv_nsec);
-  return LrsRequestEncode(request, arena.ptr());
-}
-
-grpc_error* XdsLrsResponseDecodeAndParse(
-    const grpc_slice& encoded_response,
-    grpc_core::UniquePtr<char>* cluster_name,
-    grpc_millis* load_reporting_interval) {
+    google_protobuf_Duration_set_seconds(load_report_interval, timespec.tv_sec);
+    google_protobuf_Duration_set_nanos(load_report_interval, timespec.tv_nsec);
+  }
+  MaybeLogLrsRequest(client_, tracer_, request);
+  return SerializeLrsRequest(request, arena.ptr());
+}
+
+grpc_error* XdsApi::ParseLrsResponse(const grpc_slice& encoded_response,
+                                     std::set<std::string>* cluster_names,
+                                     grpc_millis* load_reporting_interval) {
   upb::Arena arena;
   // Decode the response.
   const envoy_service_load_stats_v2_LoadStatsResponse* decoded_response =
@@ -554,19 +1754,16 @@ grpc_error* XdsLrsResponseDecodeAndParse(
           GRPC_SLICE_LENGTH(encoded_response), arena.ptr());
   // Parse the response.
   if (decoded_response == nullptr) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("No response found.");
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Can't decode response.");
   }
-  // Check the cluster size in the response.
+  // Store the cluster names.
   size_t size;
   const upb_strview* clusters =
       envoy_service_load_stats_v2_LoadStatsResponse_clusters(decoded_response,
                                                              &size);
-  if (size != 1) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "The number of clusters (server names) is not 1.");
+  for (size_t i = 0; i < size; ++i) {
+    cluster_names->emplace(clusters[i].data, clusters[i].size);
   }
-  // Get the cluster name for reporting loads.
-  *cluster_name = StringCopy(clusters[0]);
   // Get the load report interval.
   const google_protobuf_Duration* load_reporting_interval_duration =
       envoy_service_load_stats_v2_LoadStatsResponse_load_reporting_interval(