grpc 1.27.0 → 1.30.2

data/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h

@@ -80,10 +80,6 @@ class FakeResolverResponseGenerator
   // Set the corresponding FakeResolver to this generator.
   void SetFakeResolver(RefCountedPtr<FakeResolver> resolver);
 
-  static void SetResponseLocked(void* arg, grpc_error* error);
-  static void SetReresolutionResponseLocked(void* arg, grpc_error* error);
-  static void SetFailureLocked(void* arg, grpc_error* error);
-
   // Mutex protecting the members below.
   Mutex mu_;
   RefCountedPtr<FakeResolver> resolver_;

data/src/core/ext/filters/client_channel/resolver/sockaddr/sockaddr_resolver.cc

@@ -31,9 +31,9 @@
 #include "src/core/ext/filters/client_channel/server_address.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
-#include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
+#include "src/core/lib/iomgr/work_serializer.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 
@@ -57,7 +57,7 @@ class SockaddrResolver : public Resolver {
 
 SockaddrResolver::SockaddrResolver(ServerAddressList addresses,
                                    ResolverArgs args)
-    : Resolver(args.combiner, std::move(args.result_handler)),
+    : Resolver(std::move(args.work_serializer), std::move(args.result_handler)),
       addresses_(std::move(addresses)),
       channel_args_(grpc_channel_args_copy(args.args)) {}
 
@@ -176,12 +176,12 @@ class UnixResolverFactory : public ResolverFactory {
 
 void grpc_resolver_sockaddr_init() {
   grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-      grpc_core::MakeUnique<grpc_core::IPv4ResolverFactory>());
+      absl::make_unique<grpc_core::IPv4ResolverFactory>());
   grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-      grpc_core::MakeUnique<grpc_core::IPv6ResolverFactory>());
+      absl::make_unique<grpc_core::IPv6ResolverFactory>());
 #ifdef GRPC_HAVE_UNIX_SOCKET
   grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-      grpc_core::MakeUnique<grpc_core::UnixResolverFactory>());
+      absl::make_unique<grpc_core::UnixResolverFactory>());
 #endif
 }
 

data/src/core/ext/filters/client_channel/resolver/xds/xds_resolver.cc

@@ -20,10 +20,11 @@
 
 #include "src/core/ext/filters/client_channel/resolver_registry.h"
 #include "src/core/ext/filters/client_channel/xds/xds_client.h"
-#include "src/core/lib/gprpp/string_view.h"
 
 namespace grpc_core {
 
+TraceFlag grpc_xds_resolver_trace(false, "xds_resolver");
+
 namespace {
 
 //
@@ -33,19 +34,34 @@ namespace {
 class XdsResolver : public Resolver {
  public:
   explicit XdsResolver(ResolverArgs args)
-      : Resolver(args.combiner, std::move(args.result_handler)),
+      : Resolver(std::move(args.work_serializer),
+                 std::move(args.result_handler)),
         args_(grpc_channel_args_copy(args.args)),
         interested_parties_(args.pollset_set) {
     char* path = args.uri->path;
     if (path[0] == '/') ++path;
-    server_name_.reset(gpr_strdup(path));
+    server_name_ = path;
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+      gpr_log(GPR_INFO, "[xds_resolver %p] created for server name %s", this,
+              server_name_.c_str());
+    }
   }
 
-  ~XdsResolver() override { grpc_channel_args_destroy(args_); }
+  ~XdsResolver() override {
+    grpc_channel_args_destroy(args_);
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+      gpr_log(GPR_INFO, "[xds_resolver %p] destroyed", this);
+    }
+  }
 
   void StartLocked() override;
 
-  void ShutdownLocked() override { xds_client_.reset(); }
+  void ShutdownLocked() override {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+      gpr_log(GPR_INFO, "[xds_resolver %p] shutting down", this);
+    }
+    xds_client_.reset();
+  }
 
  private:
   class ServiceConfigWatcher : public XdsClient::ServiceConfigWatcherInterface {
@@ -55,12 +71,13 @@ class XdsResolver : public Resolver {
     void OnServiceConfigChanged(
         RefCountedPtr<ServiceConfig> service_config) override;
     void OnError(grpc_error* error) override;
+    void OnResourceDoesNotExist() override;
 
    private:
     RefCountedPtr<XdsResolver> resolver_;
   };
 
-  grpc_core::UniquePtr<char> server_name_;
+  std::string server_name_;
   const grpc_channel_args* args_;
   grpc_pollset_set* interested_parties_;
   OrphanablePtr<XdsClient> xds_client_;
@@ -68,6 +85,11 @@ class XdsResolver : public Resolver {
 
 void XdsResolver::ServiceConfigWatcher::OnServiceConfigChanged(
     RefCountedPtr<ServiceConfig> service_config) {
+  if (resolver_->xds_client_ == nullptr) return;
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+    gpr_log(GPR_INFO, "[xds_resolver %p] received updated service config: %s",
+            resolver_.get(), service_config->json_string().c_str());
+  }
   grpc_arg xds_client_arg = resolver_->xds_client_->MakeChannelArg();
   Result result;
   result.args =
@@ -77,6 +99,9 @@ void XdsResolver::ServiceConfigWatcher::OnServiceConfigChanged(
 }
 
 void XdsResolver::ServiceConfigWatcher::OnError(grpc_error* error) {
+  if (resolver_->xds_client_ == nullptr) return;
+  gpr_log(GPR_ERROR, "[xds_resolver %p] received error: %s", resolver_.get(),
+          grpc_error_string(error));
   grpc_arg xds_client_arg = resolver_->xds_client_->MakeChannelArg();
   Result result;
   result.args =
@@ -85,11 +110,25 @@ void XdsResolver::ServiceConfigWatcher::OnError(grpc_error* error) {
   resolver_->result_handler()->ReturnResult(std::move(result));
 }
 
+void XdsResolver::ServiceConfigWatcher::OnResourceDoesNotExist() {
+  if (resolver_->xds_client_ == nullptr) return;
+  gpr_log(GPR_ERROR,
+          "[xds_resolver %p] LDS/RDS resource does not exist -- returning "
+          "empty service config",
+          resolver_.get());
+  Result result;
+  result.service_config =
+      ServiceConfig::Create("{}", &result.service_config_error);
+  GPR_ASSERT(result.service_config != nullptr);
+  result.args = grpc_channel_args_copy(resolver_->args_);
+  resolver_->result_handler()->ReturnResult(std::move(result));
+}
+
 void XdsResolver::StartLocked() {
   grpc_error* error = GRPC_ERROR_NONE;
   xds_client_ = MakeOrphanable<XdsClient>(
-      combiner(), interested_parties_, StringView(server_name_.get()),
-      MakeUnique<ServiceConfigWatcher>(Ref()), *args_, &error);
+      work_serializer(), interested_parties_, server_name_,
+      absl::make_unique<ServiceConfigWatcher>(Ref()), *args_, &error);
   if (error != GRPC_ERROR_NONE) {
     gpr_log(GPR_ERROR,
             "Failed to create xds client -- channel will remain in "
@@ -105,6 +144,8 @@ void XdsResolver::StartLocked() {
 
 class XdsResolverFactory : public ResolverFactory {
  public:
+  explicit XdsResolverFactory(const char* scheme) : scheme_(scheme) {}
+
   bool IsValidUri(const grpc_uri* uri) const override {
     if (GPR_UNLIKELY(0 != strcmp(uri->authority, ""))) {
       gpr_log(GPR_ERROR, "URI authority not supported");
@@ -118,16 +159,26 @@ class XdsResolverFactory : public ResolverFactory {
     return MakeOrphanable<XdsResolver>(std::move(args));
   }
 
-  const char* scheme() const override { return "xds-experimental"; }
+  const char* scheme() const override { return scheme_; }
+
+ private:
+  const char* scheme_;
 };
 
+constexpr char kXdsScheme[] = "xds";
+constexpr char kXdsExperimentalScheme[] = "xds-experimental";
+
 }  // namespace
 
 }  // namespace grpc_core
 
 void grpc_resolver_xds_init() {
   grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-      grpc_core::MakeUnique<grpc_core::XdsResolverFactory>());
+      absl::make_unique<grpc_core::XdsResolverFactory>(grpc_core::kXdsScheme));
+  // TODO(roth): Remov this in the 1.31 release.
+  grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
+      absl::make_unique<grpc_core::XdsResolverFactory>(
+          grpc_core::kXdsExperimentalScheme));
 }
 
 void grpc_resolver_xds_shutdown() {}

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

@@ -38,8 +38,8 @@ struct ResolverArgs {
   const grpc_channel_args* args = nullptr;
   /// Used to drive I/O in the name resolution process.
   grpc_pollset_set* pollset_set = nullptr;
-  /// The combiner under which all resolver calls will be run.
-  Combiner* combiner = nullptr;
+  /// The work_serializer under which all resolver calls will be run.
+  std::shared_ptr<WorkSerializer> work_serializer;
   /// The result handler to be used by the resolver.
   std::unique_ptr<Resolver::ResultHandler> result_handler;
 };

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

@@ -22,6 +22,8 @@
 
 #include <string.h>
 
+#include "absl/container/inlined_vector.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -90,7 +92,7 @@ class RegistryState {
   // more factories are needed and the additional allocations are
   // hurting performance (which is unlikely, since these allocations
   // only occur at gRPC initialization time).
-  InlinedVector<std::unique_ptr<ResolverFactory>, 10> factories_;
+  absl::InlinedVector<std::unique_ptr<ResolverFactory>, 10> factories_;
   grpc_core::UniquePtr<char> default_prefix_;
 };
 
@@ -145,7 +147,8 @@ bool ResolverRegistry::IsValidTarget(const char* target) {
 
 OrphanablePtr<Resolver> ResolverRegistry::CreateResolver(
     const char* target, const grpc_channel_args* args,
-    grpc_pollset_set* pollset_set, Combiner* combiner,
+    grpc_pollset_set* pollset_set,
+    std::shared_ptr<WorkSerializer> work_serializer,
     std::unique_ptr<Resolver::ResultHandler> result_handler) {
   GPR_ASSERT(g_state != nullptr);
   grpc_uri* uri = nullptr;
@@ -156,7 +159,7 @@ OrphanablePtr ResolverRegistry::CreateResolver(
   resolver_args.uri = uri;
   resolver_args.args = args;
   resolver_args.pollset_set = pollset_set;
-  resolver_args.combiner = combiner;
+  resolver_args.work_serializer = std::move(work_serializer);
   resolver_args.result_handler = std::move(result_handler);
   OrphanablePtr<Resolver> resolver =
       factory == nullptr ? nullptr

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

@@ -22,7 +22,6 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/filters/client_channel/resolver_factory.h"
-#include "src/core/lib/gprpp/inlined_vector.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/pollset_set.h"
@@ -61,15 +60,16 @@ class ResolverRegistry {
   /// prepends default_prefix to target and tries again.
   /// If a resolver factory is found, uses it to instantiate a resolver and
   /// returns it; otherwise, returns nullptr.
-  /// \a args, \a pollset_set, and \a combiner are passed to the factory's
-  /// \a CreateResolver() method.
-  /// \a args are the channel args to be included in resolver results.
-  /// \a pollset_set is used to drive I/O in the name resolution process.
-  /// \a combiner is the combiner under which all resolver calls will be run.
-  /// \a result_handler is used to return results from the resolver.
+  /// \a args, \a pollset_set, and \a work_serializer are passed to the
+  /// factory's \a CreateResolver() method. \a args are the channel args to be
+  /// included in resolver results. \a pollset_set is used to drive I/O in the
+  /// name resolution process. \a work_serializer is the work_serializer under
+  /// which all resolver calls will be run. \a result_handler is used to return
+  /// results from the resolver.
   static OrphanablePtr<Resolver> CreateResolver(
       const char* target, const grpc_channel_args* args,
-      grpc_pollset_set* pollset_set, Combiner* combiner,
+      grpc_pollset_set* pollset_set,
+      std::shared_ptr<WorkSerializer> work_serializer,
       std::unique_ptr<Resolver::ResultHandler> result_handler);
 
   /// Returns the default authority to pass from a client for \a target.

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

@@ -24,6 +24,8 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "absl/types/optional.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -35,7 +37,6 @@
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/gprpp/optional.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 // As per the retry design, we do not allow more than 5 retry attempts.
@@ -53,8 +54,9 @@ size_t ClientChannelServiceConfigParser::ParserIndex() {
 }
 
 void ClientChannelServiceConfigParser::Register() {
-  g_client_channel_service_config_parser_index = ServiceConfig::RegisterParser(
-      MakeUnique<ClientChannelServiceConfigParser>());
+  g_client_channel_service_config_parser_index =
+      ServiceConfigParser::RegisterParser(
+          absl::make_unique<ClientChannelServiceConfigParser>());
 }
 
 namespace {
@@ -62,11 +64,11 @@ namespace {
 // Parses a JSON field of the form generated for a google.proto.Duration
 // proto message, as per:
 //   https://developers.google.com/protocol-buffers/docs/proto3#json
-bool ParseDuration(grpc_json* field, grpc_millis* duration) {
-  if (field->type != GRPC_JSON_STRING) return false;
-  size_t len = strlen(field->value);
-  if (field->value[len - 1] != 's') return false;
-  grpc_core::UniquePtr<char> buf(gpr_strdup(field->value));
+bool ParseDuration(const Json& field, grpc_millis* duration) {
+  if (field.type() != Json::Type::STRING) return false;
+  size_t len = field.string_value().size();
+  if (field.string_value()[len - 1] != 's') return false;
+  grpc_core::UniquePtr<char> buf(gpr_strdup(field.string_value().c_str()));
   *(buf.get() + len - 1) = '\0';  // Remove trailing 's'.
   char* decimal_point = strchr(buf.get(), '.');
   int nanos = 0;
@@ -92,109 +94,92 @@ bool ParseDuration(grpc_json* field, grpc_millis* duration) {
 }
 
 std::unique_ptr<ClientChannelMethodParsedConfig::RetryPolicy> ParseRetryPolicy(
-    grpc_json* field, grpc_error** error) {
+    const Json& json, grpc_error** error) {
   GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
   auto retry_policy =
-      MakeUnique<ClientChannelMethodParsedConfig::RetryPolicy>();
-  if (field->type != GRPC_JSON_OBJECT) {
+      absl::make_unique<ClientChannelMethodParsedConfig::RetryPolicy>();
+  if (json.type() != Json::Type::OBJECT) {
     *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "field:retryPolicy error:should be of type object");
     return nullptr;
   }
-  InlinedVector<grpc_error*, 4> error_list;
-  for (grpc_json* sub_field = field->child; sub_field != nullptr;
-       sub_field = sub_field->next) {
-    if (sub_field->key == nullptr) continue;
-    if (strcmp(sub_field->key, "maxAttempts") == 0) {
-      if (retry_policy->max_attempts != 0) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:maxAttempts error:Duplicate entry"));
-      }  // Duplicate. Continue Parsing
-      if (sub_field->type != GRPC_JSON_NUMBER) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:maxAttempts error:should be of type number"));
-        continue;
-      }
-      retry_policy->max_attempts = gpr_parse_nonnegative_int(sub_field->value);
+  std::vector<grpc_error*> error_list;
+  // Parse maxAttempts.
+  auto it = json.object_value().find("maxAttempts");
+  if (it != json.object_value().end()) {
+    if (it->second.type() != Json::Type::NUMBER) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:maxAttempts error:should be of type number"));
+    } else {
+      retry_policy->max_attempts =
+          gpr_parse_nonnegative_int(it->second.string_value().c_str());
       if (retry_policy->max_attempts <= 1) {
         error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
             "field:maxAttempts error:should be at least 2"));
-        continue;
-      }
-      if (retry_policy->max_attempts > MAX_MAX_RETRY_ATTEMPTS) {
+      } else if (retry_policy->max_attempts > MAX_MAX_RETRY_ATTEMPTS) {
         gpr_log(GPR_ERROR,
                 "service config: clamped retryPolicy.maxAttempts at %d",
                 MAX_MAX_RETRY_ATTEMPTS);
         retry_policy->max_attempts = MAX_MAX_RETRY_ATTEMPTS;
       }
-    } else if (strcmp(sub_field->key, "initialBackoff") == 0) {
-      if (retry_policy->initial_backoff > 0) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:initialBackoff error:Duplicate entry"));
-      }  // Duplicate, continue parsing.
-      if (!ParseDuration(sub_field, &retry_policy->initial_backoff)) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:initialBackoff error:Failed to parse"));
-        continue;
-      }
-      if (retry_policy->initial_backoff == 0) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:initialBackoff error:must be greater than 0"));
-      }
-    } else if (strcmp(sub_field->key, "maxBackoff") == 0) {
-      if (retry_policy->max_backoff > 0) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:maxBackoff error:Duplicate entry"));
-      }  // Duplicate, continue parsing.
-      if (!ParseDuration(sub_field, &retry_policy->max_backoff)) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:maxBackoff error:failed to parse"));
-        continue;
-      }
-      if (retry_policy->max_backoff == 0) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:maxBackoff error:should be greater than 0"));
-      }
-    } else if (strcmp(sub_field->key, "backoffMultiplier") == 0) {
-      if (retry_policy->backoff_multiplier != 0) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:backoffMultiplier error:Duplicate entry"));
-      }  // Duplicate, continue parsing.
-      if (sub_field->type != GRPC_JSON_NUMBER) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:backoffMultiplier error:should be of type number"));
-        continue;
-      }
-      if (sscanf(sub_field->value, "%f", &retry_policy->backoff_multiplier) !=
-          1) {
+    }
+  }
+  // Parse initialBackoff.
+  it = json.object_value().find("initialBackoff");
+  if (it != json.object_value().end()) {
+    if (!ParseDuration(it->second, &retry_policy->initial_backoff)) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:initialBackoff error:Failed to parse"));
+    } else if (retry_policy->initial_backoff == 0) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:initialBackoff error:must be greater than 0"));
+    }
+  }
+  // Parse maxBackoff.
+  it = json.object_value().find("maxBackoff");
+  if (it != json.object_value().end()) {
+    if (!ParseDuration(it->second, &retry_policy->max_backoff)) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:maxBackoff error:failed to parse"));
+    } else if (retry_policy->max_backoff == 0) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:maxBackoff error:should be greater than 0"));
+    }
+  }
+  // Parse backoffMultiplier.
+  it = json.object_value().find("backoffMultiplier");
+  if (it != json.object_value().end()) {
+    if (it->second.type() != Json::Type::NUMBER) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:backoffMultiplier error:should be of type number"));
+    } else {
+      if (sscanf(it->second.string_value().c_str(), "%f",
+                 &retry_policy->backoff_multiplier) != 1) {
         error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
             "field:backoffMultiplier error:failed to parse"));
-        continue;
-      }
-      if (retry_policy->backoff_multiplier <= 0) {
+      } else if (retry_policy->backoff_multiplier <= 0) {
         error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
             "field:backoffMultiplier error:should be greater than 0"));
       }
-    } else if (strcmp(sub_field->key, "retryableStatusCodes") == 0) {
-      if (!retry_policy->retryable_status_codes.Empty()) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:retryableStatusCodes error:Duplicate entry"));
-      }  // Duplicate, continue parsing.
-      if (sub_field->type != GRPC_JSON_ARRAY) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:retryableStatusCodes error:should be of type array"));
-        continue;
-      }
-      for (grpc_json* element = sub_field->child; element != nullptr;
-           element = element->next) {
-        if (element->type != GRPC_JSON_STRING) {
+    }
+  }
+  // Parse retryableStatusCodes.
+  it = json.object_value().find("retryableStatusCodes");
+  if (it != json.object_value().end()) {
+    if (it->second.type() != Json::Type::ARRAY) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:retryableStatusCodes error:should be of type array"));
+    } else {
+      for (const Json& element : it->second.array_value()) {
+        if (element.type() != Json::Type::STRING) {
           error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
               "field:retryableStatusCodes error:status codes should be of type "
               "string"));
           continue;
         }
         grpc_status_code status;
-        if (!grpc_status_code_from_string(element->value, &status)) {
+        if (!grpc_status_code_from_string(element.string_value().c_str(),
+                                          &status)) {
           error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
               "field:retryableStatusCodes error:failed to parse status code"));
           continue;
@@ -222,34 +207,100 @@ std::unique_ptr ParseRetryPolicy(
   return *error == GRPC_ERROR_NONE ? std::move(retry_policy) : nullptr;
 }
 
-const char* ParseHealthCheckConfig(const grpc_json* field, grpc_error** error) {
+grpc_error* ParseRetryThrottling(
+    const Json& json,
+    ClientChannelGlobalParsedConfig::RetryThrottling* retry_throttling) {
+  if (json.type() != Json::Type::OBJECT) {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "field:retryThrottling error:Type should be object");
+  }
+  std::vector<grpc_error*> error_list;
+  // Parse maxTokens.
+  auto it = json.object_value().find("maxTokens");
+  if (it == json.object_value().end()) {
+    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "field:retryThrottling field:maxTokens error:Not found"));
+  } else if (it->second.type() != Json::Type::NUMBER) {
+    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "field:retryThrottling field:maxTokens error:Type should be "
+        "number"));
+  } else {
+    retry_throttling->max_milli_tokens =
+        gpr_parse_nonnegative_int(it->second.string_value().c_str()) * 1000;
+    if (retry_throttling->max_milli_tokens <= 0) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:retryThrottling field:maxTokens error:should be "
+          "greater than zero"));
+    }
+  }
+  // Parse tokenRatio.
+  it = json.object_value().find("tokenRatio");
+  if (it == json.object_value().end()) {
+    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "field:retryThrottling field:tokenRatio error:Not found"));
+  } else if (it->second.type() != Json::Type::NUMBER) {
+    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "field:retryThrottling field:tokenRatio error:type should be "
+        "number"));
+  } else {
+    // We support up to 3 decimal digits.
+    size_t whole_len = it->second.string_value().size();
+    const char* value = it->second.string_value().c_str();
+    uint32_t multiplier = 1;
+    uint32_t decimal_value = 0;
+    const char* decimal_point = strchr(value, '.');
+    if (decimal_point != nullptr) {
+      whole_len = static_cast<size_t>(decimal_point - value);
+      multiplier = 1000;
+      size_t decimal_len = strlen(decimal_point + 1);
+      if (decimal_len > 3) decimal_len = 3;
+      if (!gpr_parse_bytes_to_uint32(decimal_point + 1, decimal_len,
+                                     &decimal_value)) {
+        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "field:retryThrottling field:tokenRatio error:Failed "
+            "parsing"));
+        return GRPC_ERROR_CREATE_FROM_VECTOR("retryPolicy", &error_list);
+      }
+      uint32_t decimal_multiplier = 1;
+      for (size_t i = 0; i < (3 - decimal_len); ++i) {
+        decimal_multiplier *= 10;
+      }
+      decimal_value *= decimal_multiplier;
+    }
+    uint32_t whole_value;
+    if (!gpr_parse_bytes_to_uint32(value, whole_len, &whole_value)) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:retryThrottling field:tokenRatio error:Failed "
+          "parsing"));
+      return GRPC_ERROR_CREATE_FROM_VECTOR("retryPolicy", &error_list);
+    }
+    retry_throttling->milli_token_ratio =
+        static_cast<int>((whole_value * multiplier) + decimal_value);
+    if (retry_throttling->milli_token_ratio <= 0) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:retryThrottling field:tokenRatio error:value should "
+          "be greater than 0"));
+    }
+  }
+  return GRPC_ERROR_CREATE_FROM_VECTOR("retryPolicy", &error_list);
+}
+
+const char* ParseHealthCheckConfig(const Json& field, grpc_error** error) {
   GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
   const char* service_name = nullptr;
-  GPR_DEBUG_ASSERT(strcmp(field->key, "healthCheckConfig") == 0);
-  if (field->type != GRPC_JSON_OBJECT) {
+  if (field.type() != Json::Type::OBJECT) {
     *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "field:healthCheckConfig error:should be of type object");
     return nullptr;
   }
-  InlinedVector<grpc_error*, 2> error_list;
-  for (grpc_json* sub_field = field->child; sub_field != nullptr;
-       sub_field = sub_field->next) {
-    if (sub_field->key == nullptr) {
-      GPR_DEBUG_ASSERT(false);
-      continue;
-    }
-    if (strcmp(sub_field->key, "serviceName") == 0) {
-      if (service_name != nullptr) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:serviceName error:Duplicate "
-            "entry"));
-      }  // Duplicate. Continue parsing
-      if (sub_field->type != GRPC_JSON_STRING) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:serviceName error:should be of type string"));
-        continue;
-      }
-      service_name = sub_field->value;
+  std::vector<grpc_error*> error_list;
+  auto it = field.object_value().find("serviceName");
+  if (it != field.object_value().end()) {
+    if (it->second.type() != Json::Type::STRING) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:serviceName error:should be of type string"));
+    } else {
+      service_name = it->second.string_value().c_str();
     }
   }
   if (!error_list.empty()) {
@@ -262,53 +313,43 @@ const char* ParseHealthCheckConfig(const grpc_json* field, grpc_error** error) {
 
 }  // namespace
 
-std::unique_ptr<ServiceConfig::ParsedConfig>
-ClientChannelServiceConfigParser::ParseGlobalParams(const grpc_json* json,
+std::unique_ptr<ServiceConfigParser::ParsedConfig>
+ClientChannelServiceConfigParser::ParseGlobalParams(const Json& json,
                                                     grpc_error** error) {
   GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
-  InlinedVector<grpc_error*, 4> error_list;
+  std::vector<grpc_error*> error_list;
   RefCountedPtr<LoadBalancingPolicy::Config> parsed_lb_config;
-  grpc_core::UniquePtr<char> lb_policy_name;
-  Optional<ClientChannelGlobalParsedConfig::RetryThrottling> retry_throttling;
+  std::string lb_policy_name;
+  absl::optional<ClientChannelGlobalParsedConfig::RetryThrottling>
+      retry_throttling;
   const char* health_check_service_name = nullptr;
-  for (grpc_json* field = json->child; field != nullptr; field = field->next) {
-    if (field->key == nullptr) {
-      continue;  // Not the LB config global parameter
+  // Parse LB config.
+  auto it = json.object_value().find("loadBalancingConfig");
+  if (it != json.object_value().end()) {
+    grpc_error* parse_error = GRPC_ERROR_NONE;
+    parsed_lb_config = LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
+        it->second, &parse_error);
+    if (parsed_lb_config == nullptr) {
+      std::vector<grpc_error*> lb_errors;
+      lb_errors.push_back(parse_error);
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_VECTOR(
+          "field:loadBalancingConfig", &lb_errors));
     }
-    // Parsed Load balancing config
-    if (strcmp(field->key, "loadBalancingConfig") == 0) {
-      if (parsed_lb_config != nullptr) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:loadBalancingConfig error:Duplicate entry"));
-      }  // Duplicate, continue parsing.
-      grpc_error* parse_error = GRPC_ERROR_NONE;
-      parsed_lb_config = LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
-          field, &parse_error);
-      if (parsed_lb_config == nullptr) {
-        error_list.push_back(parse_error);
-      }
-    }
-    // Parse deprecated loadBalancingPolicy
-    if (strcmp(field->key, "loadBalancingPolicy") == 0) {
-      if (lb_policy_name != nullptr) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:loadBalancingPolicy error:Duplicate entry"));
-      }  // Duplicate, continue parsing.
-      if (field->type != GRPC_JSON_STRING) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:loadBalancingPolicy error:type should be string"));
-        continue;
-      }
-      lb_policy_name.reset(gpr_strdup(field->value));
-      char* lb_policy = lb_policy_name.get();
-      if (lb_policy != nullptr) {
-        for (size_t i = 0; i < strlen(lb_policy); ++i) {
-          lb_policy[i] = tolower(lb_policy[i]);
-        }
+  }
+  // Parse deprecated LB policy.
+  it = json.object_value().find("loadBalancingPolicy");
+  if (it != json.object_value().end()) {
+    if (it->second.type() != Json::Type::STRING) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:loadBalancingPolicy error:type should be string"));
+    } else {
+      lb_policy_name = it->second.string_value();
+      for (size_t i = 0; i < lb_policy_name.size(); ++i) {
+        lb_policy_name[i] = tolower(lb_policy_name[i]);
       }
       bool requires_config = false;
       if (!LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
-              lb_policy, &requires_config)) {
+              lb_policy_name.c_str(), &requires_config)) {
         error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
             "field:loadBalancingPolicy error:Unknown lb policy"));
       } else if (requires_config) {
@@ -316,183 +357,84 @@ ClientChannelServiceConfigParser::ParseGlobalParams(const grpc_json* json,
         gpr_asprintf(&error_msg,
                      "field:loadBalancingPolicy error:%s requires a config. "
                      "Please use loadBalancingConfig instead.",
-                     lb_policy);
+                     lb_policy_name.c_str());
         error_list.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_msg));
         gpr_free(error_msg);
       }
     }
-    // Parse retry throttling
-    if (strcmp(field->key, "retryThrottling") == 0) {
-      if (retry_throttling.has_value()) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:retryThrottling error:Duplicate entry"));
-      }  // Duplicate, continue parsing.
-      if (field->type != GRPC_JSON_OBJECT) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:retryThrottling error:Type should be object"));
-        continue;
-      }
-      Optional<int> max_milli_tokens;
-      Optional<int> milli_token_ratio;
-      for (grpc_json* sub_field = field->child; sub_field != nullptr;
-           sub_field = sub_field->next) {
-        if (sub_field->key == nullptr) continue;
-        if (strcmp(sub_field->key, "maxTokens") == 0) {
-          if (max_milli_tokens.has_value()) {
-            error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                "field:retryThrottling field:maxTokens error:Duplicate "
-                "entry"));
-          }  // Duplicate, continue parsing.
-          if (sub_field->type != GRPC_JSON_NUMBER) {
-            error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                "field:retryThrottling field:maxTokens error:Type should be "
-                "number"));
-          } else {
-            max_milli_tokens.set(gpr_parse_nonnegative_int(sub_field->value) *
-                                 1000);
-            if (max_milli_tokens.value() <= 0) {
-              error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                  "field:retryThrottling field:maxTokens error:should be "
-                  "greater than zero"));
-            }
-          }
-        } else if (strcmp(sub_field->key, "tokenRatio") == 0) {
-          if (milli_token_ratio.has_value()) {
-            error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                "field:retryThrottling field:tokenRatio error:Duplicate "
-                "entry"));
-          }  // Duplicate, continue parsing.
-          if (sub_field->type != GRPC_JSON_NUMBER) {
-            error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                "field:retryThrottling field:tokenRatio error:type should be "
-                "number"));
-          } else {
-            // We support up to 3 decimal digits.
-            size_t whole_len = strlen(sub_field->value);
-            uint32_t multiplier = 1;
-            uint32_t decimal_value = 0;
-            const char* decimal_point = strchr(sub_field->value, '.');
-            if (decimal_point != nullptr) {
-              whole_len = static_cast<size_t>(decimal_point - sub_field->value);
-              multiplier = 1000;
-              size_t decimal_len = strlen(decimal_point + 1);
-              if (decimal_len > 3) decimal_len = 3;
-              if (!gpr_parse_bytes_to_uint32(decimal_point + 1, decimal_len,
-                                             &decimal_value)) {
-                error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                    "field:retryThrottling field:tokenRatio error:Failed "
-                    "parsing"));
-                continue;
-              }
-              uint32_t decimal_multiplier = 1;
-              for (size_t i = 0; i < (3 - decimal_len); ++i) {
-                decimal_multiplier *= 10;
-              }
-              decimal_value *= decimal_multiplier;
-            }
-            uint32_t whole_value;
-            if (!gpr_parse_bytes_to_uint32(sub_field->value, whole_len,
-                                           &whole_value)) {
-              error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                  "field:retryThrottling field:tokenRatio error:Failed "
-                  "parsing"));
-              continue;
-            }
-            milli_token_ratio.set(
-                static_cast<int>((whole_value * multiplier) + decimal_value));
-            if (milli_token_ratio.value() <= 0) {
-              error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                  "field:retryThrottling field:tokenRatio error:value should "
-                  "be greater than 0"));
-            }
-          }
-        }
-      }
-      ClientChannelGlobalParsedConfig::RetryThrottling data;
-      if (!max_milli_tokens.has_value()) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:retryThrottling field:maxTokens error:Not found"));
-      } else {
-        data.max_milli_tokens = max_milli_tokens.value();
-      }
-      if (!milli_token_ratio.has_value()) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:retryThrottling field:tokenRatio error:Not found"));
-      } else {
-        data.milli_token_ratio = milli_token_ratio.value();
-      }
-      retry_throttling.set(data);
+  }
+  // Parse retry throttling.
+  it = json.object_value().find("retryThrottling");
+  if (it != json.object_value().end()) {
+    ClientChannelGlobalParsedConfig::RetryThrottling data;
+    grpc_error* parsing_error = ParseRetryThrottling(it->second, &data);
+    if (parsing_error != GRPC_ERROR_NONE) {
+      error_list.push_back(parsing_error);
+    } else {
+      retry_throttling.emplace(data);
     }
-    if (strcmp(field->key, "healthCheckConfig") == 0) {
-      if (health_check_service_name != nullptr) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:healthCheckConfig error:Duplicate entry"));
-      }  // Duplicate continue parsing
-      grpc_error* parsing_error = GRPC_ERROR_NONE;
-      health_check_service_name = ParseHealthCheckConfig(field, &parsing_error);
-      if (parsing_error != GRPC_ERROR_NONE) {
-        error_list.push_back(parsing_error);
-      }
+  }
+  // Parse health check config.
+  it = json.object_value().find("healthCheckConfig");
+  if (it != json.object_value().end()) {
+    grpc_error* parsing_error = GRPC_ERROR_NONE;
+    health_check_service_name =
+        ParseHealthCheckConfig(it->second, &parsing_error);
+    if (parsing_error != GRPC_ERROR_NONE) {
+      error_list.push_back(parsing_error);
     }
   }
   *error = GRPC_ERROR_CREATE_FROM_VECTOR("Client channel global parser",
                                          &error_list);
   if (*error == GRPC_ERROR_NONE) {
-    return MakeUnique<ClientChannelGlobalParsedConfig>(
+    return absl::make_unique<ClientChannelGlobalParsedConfig>(
         std::move(parsed_lb_config), std::move(lb_policy_name),
         retry_throttling, health_check_service_name);
   }
   return nullptr;
 }
 
-std::unique_ptr<ServiceConfig::ParsedConfig>
-ClientChannelServiceConfigParser::ParsePerMethodParams(const grpc_json* json,
+std::unique_ptr<ServiceConfigParser::ParsedConfig>
+ClientChannelServiceConfigParser::ParsePerMethodParams(const Json& json,
                                                        grpc_error** error) {
   GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
-  InlinedVector<grpc_error*, 4> error_list;
-  Optional<bool> wait_for_ready;
+  std::vector<grpc_error*> error_list;
+  absl::optional<bool> wait_for_ready;
   grpc_millis timeout = 0;
   std::unique_ptr<ClientChannelMethodParsedConfig::RetryPolicy> retry_policy;
-  for (grpc_json* field = json->child; field != nullptr; field = field->next) {
-    if (field->key == nullptr) continue;
-    if (strcmp(field->key, "waitForReady") == 0) {
-      if (wait_for_ready.has_value()) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:waitForReady error:Duplicate entry"));
-      }  // Duplicate, continue parsing.
-      if (field->type == GRPC_JSON_TRUE) {
-        wait_for_ready.set(true);
-      } else if (field->type == GRPC_JSON_FALSE) {
-        wait_for_ready.set(false);
-      } else {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:waitForReady error:Type should be true/false"));
-      }
-    } else if (strcmp(field->key, "timeout") == 0) {
-      if (timeout > 0) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:timeout error:Duplicate entry"));
-      }  // Duplicate, continue parsing.
-      if (!ParseDuration(field, &timeout)) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:timeout error:Failed parsing"));
-      };
-    } else if (strcmp(field->key, "retryPolicy") == 0) {
-      if (retry_policy != nullptr) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:retryPolicy error:Duplicate entry"));
-      }  // Duplicate, continue parsing.
-      grpc_error* error = GRPC_ERROR_NONE;
-      retry_policy = ParseRetryPolicy(field, &error);
-      if (retry_policy == nullptr) {
-        error_list.push_back(error);
-      }
+  // Parse waitForReady.
+  auto it = json.object_value().find("waitForReady");
+  if (it != json.object_value().end()) {
+    if (it->second.type() == Json::Type::JSON_TRUE) {
+      wait_for_ready.emplace(true);
+    } else if (it->second.type() == Json::Type::JSON_FALSE) {
+      wait_for_ready.emplace(false);
+    } else {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:waitForReady error:Type should be true/false"));
+    }
+  }
+  // Parse timeout.
+  it = json.object_value().find("timeout");
+  if (it != json.object_value().end()) {
+    if (!ParseDuration(it->second, &timeout)) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:timeout error:Failed parsing"));
+    };
+  }
+  // Parse retry policy.
+  it = json.object_value().find("retryPolicy");
+  if (it != json.object_value().end()) {
+    grpc_error* error = GRPC_ERROR_NONE;
+    retry_policy = ParseRetryPolicy(it->second, &error);
+    if (retry_policy == nullptr) {
+      error_list.push_back(error);
     }
   }
   *error = GRPC_ERROR_CREATE_FROM_VECTOR("Client channel parser", &error_list);
   if (*error == GRPC_ERROR_NONE) {
-    return MakeUnique<ClientChannelMethodParsedConfig>(timeout, wait_for_ready,
-                                                       std::move(retry_policy));
+    return absl::make_unique<ClientChannelMethodParsedConfig>(
+        timeout, wait_for_ready, std::move(retry_policy));
   }
   return nullptr;
 }