grpc 1.54.0 → 1.55.0

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

@@ -20,15 +20,19 @@
 
 #include "src/core/ext/filters/client_channel/http_proxy.h"
 
+#include <stdint.h>
 #include <string.h>
 
 #include <memory>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "absl/strings/ascii.h"
 #include "absl/strings/match.h"
+#include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
@@ -39,6 +43,8 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/address_utils/parse_address.h"
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/env.h"
@@ -52,6 +58,31 @@
 namespace grpc_core {
 namespace {
 
+bool ServerInCIDRRange(absl::string_view server_host,
+                       absl::string_view no_proxy_entry) {
+  auto server_address = StringToSockaddr(server_host, 0);
+  if (!server_address.ok()) {
+    return false;
+  }
+  std::pair<absl::string_view, absl::string_view> possible_cidr =
+      absl::StrSplit(no_proxy_entry, absl::MaxSplits('/', 2),
+                     absl::SkipEmpty());
+  if (possible_cidr.first.empty() || possible_cidr.second.empty()) {
+    return false;
+  }
+  auto proxy_address = StringToSockaddr(possible_cidr.first, 0);
+  if (!proxy_address.ok()) {
+    return false;
+  }
+  uint32_t mask_bits = 0;
+  if (absl::SimpleAtoi(possible_cidr.second, &mask_bits)) {
+    grpc_sockaddr_mask_bits(&*proxy_address, mask_bits);
+    return grpc_sockaddr_match_subnet(&*server_address, &*proxy_address,
+                                      mask_bits);
+  }
+  return false;
+}
+
 ///
 /// Parses the 'https_proxy' env var (fallback on 'http_proxy') and returns the
 /// proxy hostname to resolve or nullopt on error. Also sets 'user_cred' to user
@@ -168,7 +199,9 @@ absl::optional<std::string> HttpProxyMapper::MapName(
       std::vector<absl::string_view> no_proxy_hosts =
           absl::StrSplit(*no_proxy_str, ',', absl::SkipEmpty());
       for (const auto& no_proxy_entry : no_proxy_hosts) {
-        if (absl::EndsWithIgnoreCase(server_host, no_proxy_entry)) {
+        auto entry = absl::StripAsciiWhitespace(no_proxy_entry);
+        if (absl::EndsWithIgnoreCase(server_host, entry) ||
+            ServerInCIDRRange(server_host, entry)) {
           gpr_log(GPR_INFO, "not using proxy for host in no_proxy list '%s'",
                   std::string(server_uri).c_str());
           use_proxy = false;

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

@@ -188,8 +188,8 @@ class GrpcLbConfig : public LoadBalancingPolicy::Config {
     ValidationErrors::ScopedField field(errors, ".childPolicy");
     Json child_policy_config_json_tmp;
     const Json* child_policy_config_json;
-    auto it = json.object_value().find("childPolicy");
-    if (it == json.object_value().end()) {
+    auto it = json.object().find("childPolicy");
+    if (it == json.object().end()) {
       child_policy_config_json_tmp = Json::Array{Json::Object{
           {"round_robin", Json::Object()},
       }};

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

@@ -26,7 +26,7 @@
 
 #include "google/protobuf/duration.upb.h"
 #include "google/protobuf/timestamp.upb.h"
-#include "upb/upb.h"
+#include "upb/base/string_view.h"
 
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>

data/src/core/ext/filters/client_channel/lb_policy/grpclb/load_balancer_api.h

@@ -24,7 +24,7 @@
 
 #include <vector>
 
-#include "upb/arena.h"
+#include "upb/mem/arena.h"
 
 #include <grpc/slice.h>
 

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

@@ -992,7 +992,7 @@ class OutlierDetectionLbFactory : public LoadBalancingPolicyFactory {
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
   ParseLoadBalancingConfig(const Json& json) const override {
-    if (json.type() == Json::Type::JSON_NULL) {
+    if (json.type() == Json::Type::kNull) {
       // This policy was configured in the deprecated loadBalancingPolicy
       // field or in the client API.
       return absl::InvalidArgumentError(
@@ -1009,8 +1009,8 @@ class OutlierDetectionLbFactory : public LoadBalancingPolicyFactory {
       // Parse childPolicy manually.
       {
         ValidationErrors::ScopedField field(&errors, ".childPolicy");
-        auto it = json.object_value().find("childPolicy");
-        if (it == json.object_value().end()) {
+        auto it = json.object().find("childPolicy");
+        if (it == json.object().end()) {
           errors.AddError("field not present");
         } else {
           auto child_policy_config = CoreConfiguration::Get()
@@ -1026,6 +1026,7 @@ class OutlierDetectionLbFactory : public LoadBalancingPolicyFactory {
     }
     if (!errors.ok()) {
       return errors.status(
+          absl::StatusCode::kInvalidArgument,
           "errors validating outlier_detection LB policy config");
     }
     return MakeRefCounted<OutlierDetectionLbConfig>(outlier_detection_config,
@@ -1107,8 +1108,7 @@ const JsonLoaderInterface* OutlierDetectionConfig::JsonLoader(const JsonArgs&) {
 
 void OutlierDetectionConfig::JsonPostLoad(const Json& json, const JsonArgs&,
                                           ValidationErrors* errors) {
-  if (json.object_value().find("maxEjectionTime") ==
-      json.object_value().end()) {
+  if (json.object().find("maxEjectionTime") == json.object().end()) {
     max_ejection_time = std::max(base_ejection_time, Duration::Seconds(300));
   }
   if (max_ejection_percent > 100) {

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

@@ -853,8 +853,8 @@ void PriorityLbConfig::PriorityLbChild::JsonPostLoad(const Json& json,
                                                      const JsonArgs&,
                                                      ValidationErrors* errors) {
   ValidationErrors::ScopedField field(errors, ".config");
-  auto it = json.object_value().find("config");
-  if (it == json.object_value().end()) {
+  auto it = json.object().find("config");
+  if (it == json.object().end()) {
     errors->AddError("field not present");
     return;
   }
@@ -903,7 +903,7 @@ class PriorityLbFactory : public LoadBalancingPolicyFactory {
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
   ParseLoadBalancingConfig(const Json& json) const override {
-    if (json.type() == Json::Type::JSON_NULL) {
+    if (json.type() == Json::Type::kNull) {
       // priority was mentioned as a policy in the deprecated
       // loadBalancingPolicy field or in the client API.
       return absl::InvalidArgumentError(

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

@@ -50,7 +50,7 @@
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 #include "absl/types/optional.h"
-#include "upb/upb.h"
+#include "upb/base/string_view.h"
 #include "upb/upb.hpp"
 
 #include <grpc/byte_buffer.h>
@@ -86,6 +86,7 @@
 #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/json/json_writer.h"
 #include "src/core/lib/load_balancing/lb_policy.h"
 #include "src/core/lib/load_balancing/lb_policy_factory.h"
 #include "src/core/lib/load_balancing/lb_policy_registry.h"
@@ -116,7 +117,7 @@ constexpr absl::string_view kRls = "rls_experimental";
 const char kGrpc[] = "grpc";
 const char* kRlsRequestPath = "/grpc.lookup.v1.RouteLookupService/RouteLookup";
 const char* kFakeTargetFieldValue = "fake_target_field_value";
-const char* kRlsHeaderKey = "X-Google-RLS-Data";
+const char* kRlsHeaderKey = "x-google-rls-data";
 
 const Duration kDefaultLookupServiceTimeout = Duration::Seconds(10);
 const Duration kMaxMaxAge = Duration::Minutes(5);
@@ -751,58 +752,61 @@ void RlsLb::ChildPolicyWrapper::Orphan() {
   picker_.reset();
 }
 
-bool InsertOrUpdateChildPolicyField(const std::string& field,
-                                    const std::string& value, Json* config,
-                                    ValidationErrors* errors) {
-  if (config->type() != Json::Type::ARRAY) {
+absl::optional<Json> InsertOrUpdateChildPolicyField(const std::string& field,
+                                                    const std::string& value,
+                                                    const Json& config,
+                                                    ValidationErrors* errors) {
+  if (config.type() != Json::Type::kArray) {
     errors->AddError("is not an array");
-    return false;
+    return absl::nullopt;
   }
-  bool success = true;
-  for (size_t i = 0; i < config->array_value().size(); ++i) {
-    Json& child_json = (*config->mutable_array())[i];
+  const size_t original_num_errors = errors->size();
+  Json::Array array;
+  for (size_t i = 0; i < config.array().size(); ++i) {
+    const Json& child_json = config.array()[i];
     ValidationErrors::ScopedField json_field(errors, absl::StrCat("[", i, "]"));
-    if (child_json.type() != Json::Type::OBJECT) {
+    if (child_json.type() != Json::Type::kObject) {
       errors->AddError("is not an object");
-      success = false;
     } else {
-      Json::Object& child = *child_json.mutable_object();
+      const Json::Object& child = child_json.object();
       if (child.size() != 1) {
         errors->AddError("child policy object contains more than one field");
-        success = false;
       } else {
+        const std::string& child_name = child.begin()->first;
         ValidationErrors::ScopedField json_field(
-            errors, absl::StrCat("[\"", child.begin()->first, "\"]"));
-        Json& child_config_json = child.begin()->second;
-        if (child_config_json.type() != Json::Type::OBJECT) {
+            errors, absl::StrCat("[\"", child_name, "\"]"));
+        const Json& child_config_json = child.begin()->second;
+        if (child_config_json.type() != Json::Type::kObject) {
           errors->AddError("child policy config is not an object");
-          success = false;
         } else {
-          Json::Object& child_config = *child_config_json.mutable_object();
+          Json::Object child_config = child_config_json.object();
           child_config[field] = Json(value);
+          array.emplace_back(
+              Json::Object{{child_name, std::move(child_config)}});
         }
       }
     }
   }
-  return success;
+  if (errors->size() != original_num_errors) return absl::nullopt;
+  return array;
 }
 
 void RlsLb::ChildPolicyWrapper::StartUpdate() {
-  Json child_policy_config = lb_policy_->config_->child_policy_config();
   ValidationErrors errors;
-  GPR_ASSERT(InsertOrUpdateChildPolicyField(
+  auto child_policy_config = InsertOrUpdateChildPolicyField(
       lb_policy_->config_->child_policy_config_target_field_name(), target_,
-      &child_policy_config, &errors));
+      lb_policy_->config_->child_policy_config(), &errors);
+  GPR_ASSERT(child_policy_config.has_value());
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
     gpr_log(
         GPR_INFO,
         "[rlslb %p] ChildPolicyWrapper=%p [%s]: validating update, config: %s",
         lb_policy_.get(), this, target_.c_str(),
-        child_policy_config.Dump().c_str());
+        JsonDump(*child_policy_config).c_str());
   }
   auto config =
       CoreConfiguration::Get().lb_policy_registry().ParseLoadBalancingConfig(
-          child_policy_config);
+          *child_policy_config);
   // Returned RLS target fails the validation.
   if (!config.ok()) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
@@ -1923,7 +1927,7 @@ absl::Status RlsLb::UpdateLocked(UpdateArgs args) {
       (old_config == nullptr ||
        old_config->child_policy_config() != config_->child_policy_config())) {
     gpr_log(GPR_INFO, "[rlslb %p] updated child policy config: %s", this,
-            config_->child_policy_config().Dump().c_str());
+            JsonDump(config_->child_policy_config()).c_str());
   }
   // Swap out addresses.
   // If the new address list is an error and we have an existing address list,
@@ -2333,7 +2337,7 @@ void RlsLbConfig::RouteLookupConfig::JsonPostLoad(const Json& json,
                                                   ValidationErrors* errors) {
   // Parse grpcKeybuilders.
   auto grpc_keybuilders = LoadJsonObjectField<std::vector<GrpcKeyBuilder>>(
-      json.object_value(), args, "grpcKeybuilders", errors);
+      json.object(), args, "grpcKeybuilders", errors);
   if (grpc_keybuilders.has_value()) {
     ValidationErrors::ScopedField field(errors, ".grpcKeybuilders");
     for (size_t i = 0; i < grpc_keybuilders->size(); ++i) {
@@ -2378,8 +2382,8 @@ void RlsLbConfig::RouteLookupConfig::JsonPostLoad(const Json& json,
   // Clamp maxAge to the max allowed value.
   if (max_age > kMaxMaxAge) max_age = kMaxMaxAge;
   // If staleAge is set, then maxAge must also be set.
-  if (json.object_value().find("staleAge") != json.object_value().end() &&
-      json.object_value().find("maxAge") == json.object_value().end()) {
+  if (json.object().find("staleAge") != json.object().end() &&
+      json.object().find("maxAge") == json.object().end()) {
     ValidationErrors::ScopedField field(errors, ".maxAge");
     errors->AddError("must be set if staleAge is set");
   }
@@ -2400,8 +2404,7 @@ void RlsLbConfig::RouteLookupConfig::JsonPostLoad(const Json& json,
   {
     ValidationErrors::ScopedField field(errors, ".defaultTarget");
     if (!errors->FieldHasErrors() &&
-        json.object_value().find("defaultTarget") !=
-            json.object_value().end() &&
+        json.object().find("defaultTarget") != json.object().end() &&
         default_target.empty()) {
       errors->AddError("must be non-empty if set");
     }
@@ -2423,8 +2426,8 @@ const JsonLoaderInterface* RlsLbConfig::JsonLoader(const JsonArgs&) {
 void RlsLbConfig::JsonPostLoad(const Json& json, const JsonArgs&,
                                ValidationErrors* errors) {
   // Parse routeLookupChannelServiceConfig.
-  auto it = json.object_value().find("routeLookupChannelServiceConfig");
-  if (it != json.object_value().end()) {
+  auto it = json.object().find("routeLookupChannelServiceConfig");
+  if (it != json.object().end()) {
     ValidationErrors::ScopedField field(errors,
                                         ".routeLookupChannelServiceConfig");
     // Don't need to save the result here, just need the errors (if any).
@@ -2442,18 +2445,18 @@ void RlsLbConfig::JsonPostLoad(const Json& json, const JsonArgs&,
   // Parse childPolicy.
   {
     ValidationErrors::ScopedField field(errors, ".childPolicy");
-    auto it = json.object_value().find("childPolicy");
-    if (it == json.object_value().end()) {
+    auto it = json.object().find("childPolicy");
+    if (it == json.object().end()) {
       errors->AddError("field not present");
     } else {
       // Add target to all child policy configs in the list.
-      child_policy_config_ = it->second;
       std::string target = route_lookup_config_.default_target.empty()
                                ? kFakeTargetFieldValue
                                : route_lookup_config_.default_target;
-      if (InsertOrUpdateChildPolicyField(child_policy_config_target_field_name_,
-                                         target, &child_policy_config_,
-                                         errors)) {
+      auto child_policy_config = InsertOrUpdateChildPolicyField(
+          child_policy_config_target_field_name_, target, it->second, errors);
+      if (child_policy_config.has_value()) {
+        child_policy_config_ = std::move(*child_policy_config);
         // Parse the config.
         auto parsed_config =
             CoreConfiguration::Get()
@@ -2467,13 +2470,9 @@ void RlsLbConfig::JsonPostLoad(const Json& json, const JsonArgs&,
           // we leave the target field in place, set to the default value.
           // This slightly optimizes what we need to do later when we update
           // a child policy for a given target.
-          for (Json& config : *(child_policy_config_.mutable_array())) {
-            if (config.object_value().begin()->first ==
-                (*parsed_config)->name()) {
-              Json save_config = std::move(config);
-              child_policy_config_.mutable_array()->clear();
-              child_policy_config_.mutable_array()->push_back(
-                  std::move(save_config));
+          for (const Json& config : child_policy_config_.array()) {
+            if (config.object().begin()->first == (*parsed_config)->name()) {
+              child_policy_config_ = Json::Array{config};
               break;
             }
           }

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

@@ -76,8 +76,7 @@ TraceFlag grpc_lb_wrr_trace(false, "weighted_round_robin_lb");
 
 namespace {
 
-constexpr absl::string_view kWeightedRoundRobin =
-    "weighted_round_robin_experimental";
+constexpr absl::string_view kWeightedRoundRobin = "weighted_round_robin";
 
 // Config for WRR policy.
 class WeightedRoundRobinConfig : public LoadBalancingPolicy::Config {
@@ -988,7 +987,7 @@ class WeightedRoundRobinFactory : public LoadBalancingPolicyFactory {
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
   ParseLoadBalancingConfig(const Json& json) const override {
-    if (json.type() == Json::Type::JSON_NULL) {
+    if (json.type() == Json::Type::kNull) {
       return absl::InvalidArgumentError(
           "field:loadBalancingPolicy error:weighted_round_robin policy "
           "requires configuration. Please use loadBalancingConfig field of "

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

@@ -730,8 +730,8 @@ const JsonLoaderInterface* WeightedTargetLbConfig::ChildConfig::JsonLoader(
 void WeightedTargetLbConfig::ChildConfig::JsonPostLoad(
     const Json& json, const JsonArgs&, ValidationErrors* errors) {
   ValidationErrors::ScopedField field(errors, ".childPolicy");
-  auto it = json.object_value().find("childPolicy");
-  if (it == json.object_value().end()) {
+  auto it = json.object().find("childPolicy");
+  if (it == json.object().end()) {
     errors->AddError("field not present");
     return;
   }
@@ -764,7 +764,7 @@ class WeightedTargetLbFactory : public LoadBalancingPolicyFactory {
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
   ParseLoadBalancingConfig(const Json& json) const override {
-    if (json.type() == Json::Type::JSON_NULL) {
+    if (json.type() == Json::Type::kNull) {
       // weighted_target was mentioned as a policy in the deprecated
       // loadBalancingPolicy field or in the client API.
       return absl::InvalidArgumentError(

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

@@ -59,6 +59,7 @@
 #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/json/json_writer.h"
 #include "src/core/lib/load_balancing/lb_policy.h"
 #include "src/core/lib/load_balancing/lb_policy_factory.h"
 #include "src/core/lib/load_balancing/lb_policy_registry.h"
@@ -523,9 +524,8 @@ void CdsLb::OnClusterChanged(const std::string& name,
         },
     };
     if (GRPC_TRACE_FLAG_ENABLED(grpc_cds_lb_trace)) {
-      std::string json_str = json.Dump(/*indent=*/1);
       gpr_log(GPR_INFO, "[cdslb %p] generated config for child policy: %s",
-              this, json_str.c_str());
+              this, JsonDump(json, /*indent=*/1).c_str());
     }
     auto config =
         CoreConfiguration::Get().lb_policy_registry().ParseLoadBalancingConfig(
@@ -743,7 +743,7 @@ class CdsLbFactory : public LoadBalancingPolicyFactory {
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
   ParseLoadBalancingConfig(const Json& json) const override {
-    if (json.type() == Json::Type::JSON_NULL) {
+    if (json.type() == Json::Type::kNull) {
       // xds was mentioned as a policy in the deprecated loadBalancingPolicy
       // field or in the client API.
       return absl::InvalidArgumentError(

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

@@ -728,8 +728,8 @@ void XdsClusterImplLbConfig::JsonPostLoad(const Json& json,
   // Parse "childPolicy" field.
   {
     ValidationErrors::ScopedField field(errors, ".childPolicy");
-    auto it = json.object_value().find("childPolicy");
-    if (it == json.object_value().end()) {
+    auto it = json.object().find("childPolicy");
+    if (it == json.object().end()) {
       errors->AddError("field not present");
     } else {
       auto lb_config = CoreConfiguration::Get()
@@ -745,7 +745,7 @@ void XdsClusterImplLbConfig::JsonPostLoad(const Json& json,
   // Parse "dropCategories" field.
   {
     auto value = LoadJsonObjectField<std::vector<DropCategory>>(
-        json.object_value(), args, "dropCategories", errors);
+        json.object(), args, "dropCategories", errors);
     if (value.has_value()) {
       drop_config_ = MakeRefCounted<XdsEndpointResource::DropConfig>();
       for (size_t i = 0; i < value->size(); ++i) {
@@ -777,7 +777,7 @@ class XdsClusterImplLbFactory : public LoadBalancingPolicyFactory {
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
   ParseLoadBalancingConfig(const Json& json) const override {
-    if (json.type() == Json::Type::JSON_NULL) {
+    if (json.type() == Json::Type::kNull) {
       // This policy was configured in the deprecated loadBalancingPolicy
       // field or in the client API.
       return absl::InvalidArgumentError(

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

@@ -637,8 +637,8 @@ void XdsClusterManagerLbConfig::Child::JsonPostLoad(const Json& json,
                                                     const JsonArgs&,
                                                     ValidationErrors* errors) {
   ValidationErrors::ScopedField field(errors, ".childPolicy");
-  auto it = json.object_value().find("childPolicy");
-  if (it == json.object_value().end()) {
+  auto it = json.object().find("childPolicy");
+  if (it == json.object().end()) {
     errors->AddError("field not present");
     return;
   }
@@ -672,7 +672,7 @@ class XdsClusterManagerLbFactory : public LoadBalancingPolicyFactory {
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
   ParseLoadBalancingConfig(const Json& json) const override {
-    if (json.type() == Json::Type::JSON_NULL) {
+    if (json.type() == Json::Type::kNull) {
       // xds_cluster_manager was mentioned as a policy in the deprecated
       // loadBalancingPolicy field or in the client API.
       return absl::InvalidArgumentError(

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

@@ -63,6 +63,7 @@
 #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/json/json_writer.h"
 #include "src/core/lib/load_balancing/lb_policy.h"
 #include "src/core/lib/load_balancing/lb_policy_factory.h"
 #include "src/core/lib/load_balancing/lb_policy_registry.h"
@@ -952,11 +953,10 @@ XdsClusterResolverLb::CreateChildPolicyConfigLocked() {
        }},
   }};
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_cluster_resolver_trace)) {
-    std::string json_str = json.Dump(/*indent=*/1);
     gpr_log(
         GPR_INFO,
         "[xds_cluster_resolver_lb %p] generated config for child policy: %s",
-        this, json_str.c_str());
+        this, JsonDump(json, /*indent=*/1).c_str());
   }
   auto config =
       CoreConfiguration::Get().lb_policy_registry().ParseLoadBalancingConfig(
@@ -1060,8 +1060,8 @@ void XdsClusterResolverLbConfig::DiscoveryMechanism::JsonPostLoad(
     const Json& json, const JsonArgs& args, ValidationErrors* errors) {
   // Parse "type".
   {
-    auto type_field = LoadJsonObjectField<std::string>(json.object_value(),
-                                                       args, "type", errors);
+    auto type_field =
+        LoadJsonObjectField<std::string>(json.object(), args, "type", errors);
     if (type_field.has_value()) {
       if (*type_field == "EDS") {
         type = DiscoveryMechanismType::EDS;
@@ -1075,14 +1075,14 @@ void XdsClusterResolverLbConfig::DiscoveryMechanism::JsonPostLoad(
   }
   // Parse "edsServiceName" if type is EDS.
   if (type == DiscoveryMechanismType::EDS) {
-    auto value = LoadJsonObjectField<std::string>(json.object_value(), args,
+    auto value = LoadJsonObjectField<std::string>(json.object(), args,
                                                   "edsServiceName", errors,
                                                   /*required=*/false);
     if (value.has_value()) eds_service_name = std::move(*value);
   }
   // Parse "dnsHostname" if type is LOGICAL_DNS.
   if (type == DiscoveryMechanismType::LOGICAL_DNS) {
-    auto value = LoadJsonObjectField<std::string>(json.object_value(), args,
+    auto value = LoadJsonObjectField<std::string>(json.object(), args,
                                                   "dnsHostname", errors);
     if (value.has_value()) dns_hostname = std::move(*value);
   }
@@ -1112,8 +1112,8 @@ void XdsClusterResolverLbConfig::JsonPostLoad(const Json& json, const JsonArgs&,
   // Parse "xdsLbPolicy".
   {
     ValidationErrors::ScopedField field(errors, ".xdsLbPolicy");
-    auto it = json.object_value().find("xdsLbPolicy");
-    if (it == json.object_value().end()) {
+    auto it = json.object().find("xdsLbPolicy");
+    if (it == json.object().end()) {
       errors->AddError("field not present");
     } else {
       auto lb_config = CoreConfiguration::Get()
@@ -1145,7 +1145,7 @@ class XdsClusterResolverLbFactory : public LoadBalancingPolicyFactory {
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
   ParseLoadBalancingConfig(const Json& json) const override {
-    if (json.type() == Json::Type::JSON_NULL) {
+    if (json.type() == Json::Type::kNull) {
       // xds_cluster_resolver was mentioned as a policy in the deprecated
       // loadBalancingPolicy field or in the client API.
       return absl::InvalidArgumentError(

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

@@ -740,7 +740,7 @@ class XdsOverrideHostLbFactory : public LoadBalancingPolicyFactory {
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
   ParseLoadBalancingConfig(const Json& json) const override {
-    if (json.type() == Json::Type::JSON_NULL) {
+    if (json.type() == Json::Type::kNull) {
       // This policy was configured in the deprecated loadBalancingPolicy
       // field or in the client API.
       return absl::InvalidArgumentError(
@@ -777,8 +777,8 @@ void XdsOverrideHostLbConfig::JsonPostLoad(const Json& json,
                                            ValidationErrors* errors) {
   {
     ValidationErrors::ScopedField field(errors, ".childPolicy");
-    auto it = json.object_value().find("childPolicy");
-    if (it == json.object_value().end()) {
+    auto it = json.object().find("childPolicy");
+    if (it == json.object().end()) {
       errors->AddError("field not present");
     } else {
       auto child_policy_config = CoreConfiguration::Get()
@@ -794,7 +794,7 @@ void XdsOverrideHostLbConfig::JsonPostLoad(const Json& json,
   {
     ValidationErrors::ScopedField field(errors, ".overrideHostStatus");
     auto host_status_list = LoadJsonObjectField<std::vector<std::string>>(
-        json.object_value(), args, "overrideHostStatus", errors,
+        json.object(), args, "overrideHostStatus", errors,
         /*required=*/false);
     if (host_status_list.has_value()) {
       for (size_t i = 0; i < host_status_list->size(); ++i) {

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

@@ -45,6 +45,7 @@
 #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/json/json_writer.h"
 #include "src/core/lib/load_balancing/lb_policy.h"
 #include "src/core/lib/load_balancing/lb_policy_factory.h"
 #include "src/core/lib/load_balancing/lb_policy_registry.h"
@@ -86,8 +87,8 @@ class XdsWrrLocalityLbConfig : public LoadBalancingPolicy::Config {
   void JsonPostLoad(const Json& json, const JsonArgs&,
                     ValidationErrors* errors) {
     ValidationErrors::ScopedField field(errors, ".childPolicy");
-    auto it = json.object_value().find("childPolicy");
-    if (it == json.object_value().end()) {
+    auto it = json.object().find("childPolicy");
+    if (it == json.object().end()) {
       errors->AddError("field not present");
       return;
     }
@@ -226,7 +227,7 @@ absl::Status XdsWrrLocalityLb::UpdateLocked(UpdateArgs args) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_wrr_locality_lb_trace)) {
     gpr_log(GPR_INFO,
             "[xds_wrr_locality_lb %p] generated child policy config: %s", this,
-            child_config_json.Dump(/*indent=*/1).c_str());
+            JsonDump(child_config_json, /*indent=*/1).c_str());
   }
   // Parse config.
   auto child_config =
@@ -345,7 +346,7 @@ class XdsWrrLocalityLbFactory : public LoadBalancingPolicyFactory {
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
   ParseLoadBalancingConfig(const Json& json) const override {
-    if (json.type() == Json::Type::JSON_NULL) {
+    if (json.type() == Json::Type::kNull) {
       // xds_wrr_locality was mentioned as a policy in the deprecated
       // loadBalancingPolicy field or in the client API.
       return absl::InvalidArgumentError(