grpc 1.21.0 → 1.32.0

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

@@ -24,7 +24,6 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/ext/filters/client_channel/resolver.h"
-#include "src/core/lib/gprpp/abstract.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/pollset_set.h"
@@ -39,33 +38,34 @@ 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.
-  grpc_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.
-  UniquePtr<Resolver::ResultHandler> result_handler;
+  std::unique_ptr<Resolver::ResultHandler> result_handler;
 };
 
 class ResolverFactory {
  public:
+  /// Returns a bool indicating whether the input uri is valid to create a
+  /// resolver.
+  virtual bool IsValidUri(const grpc_uri* uri) const = 0;
+
   /// Returns a new resolver instance.
-  virtual OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const
-      GRPC_ABSTRACT;
+  virtual OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const = 0;
 
   /// Returns a string representing the default authority to use for this
   /// scheme.
-  virtual UniquePtr<char> GetDefaultAuthority(grpc_uri* uri) const {
+  virtual grpc_core::UniquePtr<char> GetDefaultAuthority(grpc_uri* uri) const {
     const char* path = uri->path;
     if (path[0] == '/') ++path;
-    return UniquePtr<char>(gpr_strdup(path));
+    return grpc_core::UniquePtr<char>(gpr_strdup(path));
   }
 
   /// Returns the URI scheme that this factory implements.
   /// Caller does NOT take ownership of result.
-  virtual const char* scheme() const GRPC_ABSTRACT;
+  virtual const char* scheme() const = 0;
 
   virtual ~ResolverFactory() {}
-
-  GRPC_ABSTRACT_BASE_CLASS
 };
 
 }  // namespace grpc_core

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

@@ -22,6 +22,9 @@
 
 #include <string.h>
 
+#include "absl/container/inlined_vector.h"
+#include "absl/strings/str_cat.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -40,7 +43,7 @@ class RegistryState {
     default_prefix_.reset(gpr_strdup(default_resolver_prefix));
   }
 
-  void RegisterResolverFactory(UniquePtr<ResolverFactory> factory) {
+  void RegisterResolverFactory(std::unique_ptr<ResolverFactory> factory) {
     for (size_t i = 0; i < factories_.size(); ++i) {
       GPR_ASSERT(strcmp(factories_[i]->scheme(), factory->scheme()) != 0);
     }
@@ -63,22 +66,22 @@ class RegistryState {
   // If \a default_prefix_ needs to be prepended, sets \a canonical_target
   // to the canonical target string.
   ResolverFactory* FindResolverFactory(const char* target, grpc_uri** uri,
-                                       char** canonical_target) const {
+                                       std::string* canonical_target) const {
     GPR_ASSERT(uri != nullptr);
     *uri = grpc_uri_parse(target, 1);
     ResolverFactory* factory =
         *uri == nullptr ? nullptr : LookupResolverFactory((*uri)->scheme);
     if (factory == nullptr) {
       grpc_uri_destroy(*uri);
-      gpr_asprintf(canonical_target, "%s%s", default_prefix_.get(), target);
-      *uri = grpc_uri_parse(*canonical_target, 1);
+      *canonical_target = absl::StrCat(default_prefix_.get(), target);
+      *uri = grpc_uri_parse(canonical_target->c_str(), 1);
       factory =
           *uri == nullptr ? nullptr : LookupResolverFactory((*uri)->scheme);
       if (factory == nullptr) {
         grpc_uri_destroy(grpc_uri_parse(target, 0));
-        grpc_uri_destroy(grpc_uri_parse(*canonical_target, 0));
+        grpc_uri_destroy(grpc_uri_parse(canonical_target->c_str(), 0));
         gpr_log(GPR_ERROR, "don't know how to resolve '%s' or '%s'", target,
-                *canonical_target);
+                canonical_target->c_str());
       }
     }
     return factory;
@@ -90,8 +93,8 @@ 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<UniquePtr<ResolverFactory>, 10> factories_;
-  UniquePtr<char> default_prefix_;
+  absl::InlinedVector<std::unique_ptr<ResolverFactory>, 10> factories_;
+  grpc_core::UniquePtr<char> default_prefix_;
 };
 
 static RegistryState* g_state = nullptr;
@@ -103,11 +106,11 @@ static RegistryState* g_state = nullptr;
 //
 
 void ResolverRegistry::Builder::InitRegistry() {
-  if (g_state == nullptr) g_state = New<RegistryState>();
+  if (g_state == nullptr) g_state = new RegistryState();
 }
 
 void ResolverRegistry::Builder::ShutdownRegistry() {
-  Delete(g_state);
+  delete g_state;
   g_state = nullptr;
 }
 
@@ -118,7 +121,7 @@ void ResolverRegistry::Builder::SetDefaultPrefix(
 }
 
 void ResolverRegistry::Builder::RegisterResolverFactory(
-    UniquePtr<ResolverFactory> factory) {
+    std::unique_ptr<ResolverFactory> factory) {
   InitRegistry();
   g_state->RegisterResolverFactory(std::move(factory));
 }
@@ -132,50 +135,62 @@ ResolverFactory* ResolverRegistry::LookupResolverFactory(const char* scheme) {
   return g_state->LookupResolverFactory(scheme);
 }
 
+bool ResolverRegistry::IsValidTarget(const char* target) {
+  grpc_uri* uri = nullptr;
+  std::string canonical_target;
+  ResolverFactory* factory =
+      g_state->FindResolverFactory(target, &uri, &canonical_target);
+  bool result = factory == nullptr ? false : factory->IsValidUri(uri);
+  grpc_uri_destroy(uri);
+  return result;
+}
+
 OrphanablePtr<Resolver> ResolverRegistry::CreateResolver(
     const char* target, const grpc_channel_args* args,
-    grpc_pollset_set* pollset_set, grpc_combiner* combiner,
-    UniquePtr<Resolver::ResultHandler> result_handler) {
+    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;
-  char* canonical_target = nullptr;
+  std::string canonical_target;
   ResolverFactory* factory =
       g_state->FindResolverFactory(target, &uri, &canonical_target);
   ResolverArgs resolver_args;
   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
                          : factory->CreateResolver(std::move(resolver_args));
   grpc_uri_destroy(uri);
-  gpr_free(canonical_target);
   return resolver;
 }
 
-UniquePtr<char> ResolverRegistry::GetDefaultAuthority(const char* target) {
+grpc_core::UniquePtr<char> ResolverRegistry::GetDefaultAuthority(
+    const char* target) {
   GPR_ASSERT(g_state != nullptr);
   grpc_uri* uri = nullptr;
-  char* canonical_target = nullptr;
+  std::string canonical_target;
   ResolverFactory* factory =
       g_state->FindResolverFactory(target, &uri, &canonical_target);
-  UniquePtr<char> authority =
+  grpc_core::UniquePtr<char> authority =
       factory == nullptr ? nullptr : factory->GetDefaultAuthority(uri);
   grpc_uri_destroy(uri);
-  gpr_free(canonical_target);
   return authority;
 }
 
-UniquePtr<char> ResolverRegistry::AddDefaultPrefixIfNeeded(const char* target) {
+grpc_core::UniquePtr<char> ResolverRegistry::AddDefaultPrefixIfNeeded(
+    const char* target) {
   GPR_ASSERT(g_state != nullptr);
   grpc_uri* uri = nullptr;
-  char* canonical_target = nullptr;
+  std::string canonical_target;
   g_state->FindResolverFactory(target, &uri, &canonical_target);
   grpc_uri_destroy(uri);
-  return UniquePtr<char>(canonical_target == nullptr ? gpr_strdup(target)
-                                                     : canonical_target);
+  return grpc_core::UniquePtr<char>(canonical_target.empty()
+                                        ? gpr_strdup(target)
+                                        : gpr_strdup(canonical_target.c_str()));
 }
 
 }  // namespace grpc_core

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"
@@ -47,9 +46,13 @@ class ResolverRegistry {
     /// Registers a resolver factory.  The factory will be used to create a
     /// resolver for any URI whose scheme matches that of the factory.
     /// Calls InitRegistry() if it has not already been called.
-    static void RegisterResolverFactory(UniquePtr<ResolverFactory> factory);
+    static void RegisterResolverFactory(
+        std::unique_ptr<ResolverFactory> factory);
   };
 
+  /// Checks whether the user input \a target is valid to create a resolver.
+  static bool IsValidTarget(const char* target);
+
   /// Creates a resolver given \a target.
   /// First tries to parse \a target as a URI. If this succeeds, tries
   /// to locate a registered resolver factory based on the URI scheme.
@@ -57,22 +60,24 @@ 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, grpc_combiner* combiner,
-      UniquePtr<Resolver::ResultHandler> result_handler);
+      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.
-  static UniquePtr<char> GetDefaultAuthority(const char* target);
+  static grpc_core::UniquePtr<char> GetDefaultAuthority(const char* target);
 
   /// Returns \a target with the default prefix prepended, if needed.
-  static UniquePtr<char> AddDefaultPrefixIfNeeded(const char* target);
+  static grpc_core::UniquePtr<char> AddDefaultPrefixIfNeeded(
+      const char* target);
 
   /// Returns the resolver factory for \a scheme.
   /// Caller does NOT own the return value.

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

@@ -24,6 +24,9 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "absl/strings/str_cat.h"
+#include "absl/types/optional.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -35,7 +38,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.
@@ -54,8 +56,8 @@ size_t ClientChannelServiceConfigParser::ParserIndex() {
 
 void ClientChannelServiceConfigParser::Register() {
   g_client_channel_service_config_parser_index =
-      ServiceConfig::RegisterParser(UniquePtr<ServiceConfig::Parser>(
-          New<ClientChannelServiceConfigParser>()));
+      ServiceConfigParser::RegisterParser(
+          absl::make_unique<ClientChannelServiceConfigParser>());
 }
 
 namespace {
@@ -63,11 +65,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;
-  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,110 +94,93 @@ bool ParseDuration(grpc_json* field, grpc_millis* duration) {
   return true;
 }
 
-UniquePtr<ClientChannelMethodParsedObject::RetryPolicy> ParseRetryPolicy(
-    grpc_json* field, grpc_error** error) {
+std::unique_ptr<ClientChannelMethodParsedConfig::RetryPolicy> ParseRetryPolicy(
+    const Json& json, grpc_error** error) {
   GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
   auto retry_policy =
-      MakeUnique<ClientChannelMethodParsedObject::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;
@@ -223,34 +208,100 @@ UniquePtr<ClientChannelMethodParsedObject::RetryPolicy> 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()) {
@@ -263,239 +314,126 @@ const char* ParseHealthCheckConfig(const grpc_json* field, grpc_error** error) {
 
 }  // namespace
 
-UniquePtr<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;
-  RefCountedPtr<ParsedLoadBalancingConfig> parsed_lb_config;
-  UniquePtr<char> lb_policy_name;
-  Optional<ClientChannelGlobalParsedObject::RetryThrottling> retry_throttling;
+  std::vector<grpc_error*> error_list;
+  RefCountedPtr<LoadBalancingPolicy::Config> parsed_lb_config;
+  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) {
-        char* error_msg;
-        gpr_asprintf(&error_msg,
-                     "field:loadBalancingPolicy error:%s requires a config. "
-                     "Please use loadBalancingConfig instead.",
-                     lb_policy);
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_msg));
-        gpr_free(error_msg);
+        error_list.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+            absl::StrCat("field:loadBalancingPolicy error:", lb_policy_name,
+                         " requires a config. Please use loadBalancingConfig "
+                         "instead.")
+                .c_str()));
       }
     }
-    // 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"));
-            }
-          }
-        }
-      }
-      ClientChannelGlobalParsedObject::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 UniquePtr<ServiceConfig::ParsedConfig>(
-        New<ClientChannelGlobalParsedObject>(
-            std::move(parsed_lb_config), std::move(lb_policy_name),
-            retry_throttling, health_check_service_name));
+    return absl::make_unique<ClientChannelGlobalParsedConfig>(
+        std::move(parsed_lb_config), std::move(lb_policy_name),
+        retry_throttling, health_check_service_name);
   }
   return nullptr;
 }
 
-UniquePtr<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;
-  UniquePtr<ClientChannelMethodParsedObject::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);
-      }
+  std::unique_ptr<ClientChannelMethodParsedConfig::RetryPolicy> retry_policy;
+  // 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 UniquePtr<ServiceConfig::ParsedConfig>(
-        New<ClientChannelMethodParsedObject>(timeout, wait_for_ready,
-                                             std::move(retry_policy)));
+    return absl::make_unique<ClientChannelMethodParsedConfig>(
+        timeout, wait_for_ready, std::move(retry_policy));
   }
   return nullptr;
 }