grpc 1.42.0 → 1.51.0

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

@@ -1,136 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_H
-
-#include <grpc/support/port_platform.h>
-
-#include <grpc/impl/codegen/grpc_types.h>
-
-#include "src/core/ext/filters/client_channel/server_address.h"
-#include "src/core/ext/service_config/service_config.h"
-#include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/iomgr/iomgr.h"
-#include "src/core/lib/iomgr/work_serializer.h"
-
-extern grpc_core::DebugOnlyTraceFlag grpc_trace_resolver_refcount;
-
-// Name associated with individual address, if available.
-#define GRPC_ARG_ADDRESS_NAME "grpc.address_name"
-
-namespace grpc_core {
-
-/// Interface for name resolution.
-///
-/// This interface is designed to support both push-based and pull-based
-/// mechanisms.  A push-based mechanism is one where the resolver will
-/// subscribe to updates for a given name, and the name service will
-/// proactively send new data to the resolver whenever the data associated
-/// with the name changes.  A pull-based mechanism is one where the resolver
-/// needs to query the name service again to get updated information (e.g.,
-/// DNS).
-///
-/// Note: All methods with a "Locked" suffix must be called from the
-/// work_serializer passed to the constructor.
-class Resolver : public InternallyRefCounted<Resolver> {
- public:
-  /// Results returned by the resolver.
-  struct Result {
-    ServerAddressList addresses;
-    RefCountedPtr<ServiceConfig> service_config;
-    grpc_error_handle service_config_error = GRPC_ERROR_NONE;
-    const grpc_channel_args* args = nullptr;
-
-    // TODO(roth): Remove everything below once grpc_error and
-    // grpc_channel_args are convert to copyable and movable C++ objects.
-    Result() = default;
-    ~Result();
-    Result(const Result& other);
-    Result(Result&& other) noexcept;
-    Result& operator=(const Result& other);
-    Result& operator=(Result&& other) noexcept;
-  };
-
-  /// A proxy object used by the resolver to return results to the
-  /// client channel.
-  class ResultHandler {
-   public:
-    virtual ~ResultHandler() {}
-
-    /// Returns a result to the channel.
-    /// Takes ownership of \a result.args.
-    virtual void ReturnResult(Result result) = 0;  // NOLINT
-
-    /// Returns a transient error to the channel.
-    /// If the resolver does not set the GRPC_ERROR_INT_GRPC_STATUS
-    /// attribute on the error, calls will be failed with status UNKNOWN.
-    virtual void ReturnError(grpc_error_handle error) = 0;
-
-    // TODO(yashkt): As part of the service config error handling
-    // changes, add a method to parse the service config JSON string.
-  };
-
-  // Not copyable nor movable.
-  Resolver(const Resolver&) = delete;
-  Resolver& operator=(const Resolver&) = delete;
-  ~Resolver() override = default;
-
-  /// Starts resolving.
-  virtual void StartLocked() = 0;
-
-  /// Asks the resolver to obtain an updated resolver result, if
-  /// applicable.
-  ///
-  /// This is useful for pull-based implementations to decide when to
-  /// re-resolve.  However, the implementation is not required to
-  /// re-resolve immediately upon receiving this call; it may instead
-  /// elect to delay based on some configured minimum time between
-  /// queries, to avoid hammering the name service with queries.
-  ///
-  /// For push-based implementations, this may be a no-op.
-  ///
-  /// Note: Implementations must not invoke any method on the
-  /// ResultHandler from within this call.
-  virtual void RequestReresolutionLocked() {}
-
-  /// Resets the re-resolution backoff, if any.
-  /// This needs to be implemented only by pull-based implementations;
-  /// for push-based implementations, it will be a no-op.
-  /// TODO(roth): Pull the backoff code out of resolver and into
-  /// client_channel, so that it can be shared across resolver
-  /// implementations.  At that point, this method can go away.
-  virtual void ResetBackoffLocked() {}
-
-  // Note: This must be invoked while holding the work_serializer.
-  void Orphan() override {
-    ShutdownLocked();
-    Unref();
-  }
-
- protected:
-  Resolver();
-
-  /// Shuts down the resolver.
-  virtual void ShutdownLocked() = 0;
-};
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_H */

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

@@ -1,75 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FACTORY_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FACTORY_H
-
-#include <grpc/support/port_platform.h>
-
-#include "absl/strings/strip.h"
-
-#include <grpc/support/string_util.h>
-
-#include "src/core/ext/filters/client_channel/resolver.h"
-#include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/iomgr/pollset_set.h"
-#include "src/core/lib/uri/uri_parser.h"
-
-namespace grpc_core {
-
-struct ResolverArgs {
-  /// The parsed URI to resolve.
-  URI uri;
-  /// The URI string.
-  std::string uri_string;
-  /// Channel args to be included in resolver results.
-  const grpc_channel_args* args = nullptr;
-  /// Used to drive I/O in the name resolution process.
-  grpc_pollset_set* pollset_set = 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;
-};
-
-class ResolverFactory {
- public:
-  /// Returns a bool indicating whether the input uri is valid to create a
-  /// resolver.
-  virtual bool IsValidUri(const URI& uri) const = 0;
-
-  /// Returns a new resolver instance.
-  virtual OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const = 0;
-
-  /// Returns a string representing the default authority to use for this
-  /// scheme.
-  virtual std::string GetDefaultAuthority(const URI& uri) const {
-    return std::string(absl::StripPrefix(uri.path(), "/"));
-  }
-
-  /// Returns the URI scheme that this factory implements.
-  /// Caller does NOT take ownership of result.
-  virtual const char* scheme() const = 0;
-
-  virtual ~ResolverFactory() {}
-};
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FACTORY_H */

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

@@ -1,195 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/ext/filters/client_channel/resolver_registry.h"
-
-#include <string.h>
-
-#include "absl/container/inlined_vector.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-
-namespace grpc_core {
-
-namespace {
-
-class RegistryState {
- public:
-  RegistryState() : default_prefix_(gpr_strdup("dns:///")) {}
-
-  void SetDefaultPrefix(const char* default_resolver_prefix) {
-    GPR_ASSERT(default_resolver_prefix != nullptr);
-    GPR_ASSERT(*default_resolver_prefix != '\0');
-    default_prefix_.reset(gpr_strdup(default_resolver_prefix));
-  }
-
-  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);
-    }
-    factories_.push_back(std::move(factory));
-  }
-
-  ResolverFactory* LookupResolverFactory(absl::string_view scheme) const {
-    for (size_t i = 0; i < factories_.size(); ++i) {
-      if (scheme == factories_[i]->scheme()) {
-        return factories_[i].get();
-      }
-    }
-    return nullptr;
-  }
-
-  // Returns the factory for the scheme of \a target.  If \a target does
-  // not parse as a URI, prepends \a default_prefix_ and tries again.
-  // If URI parsing is successful (in either attempt), sets \a uri to
-  // point to the parsed URI.
-  // If \a default_prefix_ needs to be prepended, sets \a canonical_target
-  // to the canonical target string.
-  ResolverFactory* FindResolverFactory(absl::string_view target, URI* uri,
-                                       std::string* canonical_target) const {
-    GPR_ASSERT(uri != nullptr);
-    absl::StatusOr<URI> tmp_uri = URI::Parse(target);
-    ResolverFactory* factory =
-        tmp_uri.ok() ? LookupResolverFactory(tmp_uri->scheme()) : nullptr;
-    if (factory != nullptr) {
-      *uri = std::move(*tmp_uri);
-      return factory;
-    }
-    *canonical_target = absl::StrCat(default_prefix_.get(), target);
-    absl::StatusOr<URI> tmp_uri2 = URI::Parse(*canonical_target);
-    factory =
-        tmp_uri2.ok() ? LookupResolverFactory(tmp_uri2->scheme()) : nullptr;
-    if (factory != nullptr) {
-      *uri = std::move(*tmp_uri2);
-      return factory;
-    }
-    if (!tmp_uri.ok() || !tmp_uri2.ok()) {
-      gpr_log(GPR_ERROR, "%s",
-              absl::StrFormat("Error parsing URI(s). '%s':%s; '%s':%s", target,
-                              tmp_uri.status().ToString(), *canonical_target,
-                              tmp_uri2.status().ToString())
-                  .c_str());
-      return nullptr;
-    }
-    gpr_log(GPR_ERROR, "Don't know how to resolve '%s' or '%s'.",
-            std::string(target).c_str(), canonical_target->c_str());
-    return nullptr;
-  }
-
- private:
-  // We currently support 10 factories without doing additional
-  // allocation.  This number could be raised if there is a case where
-  // more factories are needed and the additional allocations are
-  // hurting performance (which is unlikely, since these allocations
-  // only occur at gRPC initialization time).
-  absl::InlinedVector<std::unique_ptr<ResolverFactory>, 10> factories_;
-  grpc_core::UniquePtr<char> default_prefix_;
-};
-
-static RegistryState* g_state = nullptr;
-
-}  // namespace
-
-//
-// ResolverRegistry::Builder
-//
-
-void ResolverRegistry::Builder::InitRegistry() {
-  if (g_state == nullptr) g_state = new RegistryState();
-}
-
-void ResolverRegistry::Builder::ShutdownRegistry() {
-  delete g_state;
-  g_state = nullptr;
-}
-
-void ResolverRegistry::Builder::SetDefaultPrefix(const char* default_prefix) {
-  InitRegistry();
-  g_state->SetDefaultPrefix(default_prefix);
-}
-
-void ResolverRegistry::Builder::RegisterResolverFactory(
-    std::unique_ptr<ResolverFactory> factory) {
-  InitRegistry();
-  g_state->RegisterResolverFactory(std::move(factory));
-}
-
-//
-// ResolverRegistry
-//
-
-ResolverFactory* ResolverRegistry::LookupResolverFactory(const char* scheme) {
-  GPR_ASSERT(g_state != nullptr);
-  return g_state->LookupResolverFactory(scheme);
-}
-
-bool ResolverRegistry::IsValidTarget(absl::string_view target) {
-  URI uri;
-  std::string canonical_target;
-  ResolverFactory* factory =
-      g_state->FindResolverFactory(target, &uri, &canonical_target);
-  return factory == nullptr ? false : factory->IsValidUri(uri);
-}
-
-OrphanablePtr<Resolver> ResolverRegistry::CreateResolver(
-    const char* target, const grpc_channel_args* args,
-    grpc_pollset_set* pollset_set,
-    std::shared_ptr<WorkSerializer> work_serializer,
-    std::unique_ptr<Resolver::ResultHandler> result_handler) {
-  GPR_ASSERT(g_state != nullptr);
-  ResolverArgs resolver_args;
-  ResolverFactory* factory = g_state->FindResolverFactory(
-      target, &resolver_args.uri, &resolver_args.uri_string);
-  if (factory == nullptr) return nullptr;
-  if (resolver_args.uri_string.empty()) resolver_args.uri_string = target;
-  resolver_args.args = args;
-  resolver_args.pollset_set = pollset_set;
-  resolver_args.work_serializer = std::move(work_serializer);
-  resolver_args.result_handler = std::move(result_handler);
-  return factory->CreateResolver(std::move(resolver_args));
-}
-
-std::string ResolverRegistry::GetDefaultAuthority(absl::string_view target) {
-  GPR_ASSERT(g_state != nullptr);
-  URI uri;
-  std::string canonical_target;
-  ResolverFactory* factory =
-      g_state->FindResolverFactory(target, &uri, &canonical_target);
-  std::string authority =
-      factory == nullptr ? "" : factory->GetDefaultAuthority(uri);
-  return authority;
-}
-
-grpc_core::UniquePtr<char> ResolverRegistry::AddDefaultPrefixIfNeeded(
-    const char* target) {
-  GPR_ASSERT(g_state != nullptr);
-  URI uri;
-  std::string canonical_target;
-  g_state->FindResolverFactory(target, &uri, &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

@@ -1,89 +0,0 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_REGISTRY_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_REGISTRY_H
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/ext/filters/client_channel/resolver_factory.h"
-#include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/iomgr/pollset_set.h"
-
-namespace grpc_core {
-
-class ResolverRegistry {
- public:
-  /// Methods used to create and populate the ResolverRegistry.
-  /// NOT THREAD SAFE -- to be used only during global gRPC
-  /// initialization and shutdown.
-  class Builder {
-   public:
-    /// Global initialization and shutdown hooks.
-    static void InitRegistry();
-    static void ShutdownRegistry();
-
-    /// Sets the default URI prefix to \a default_prefix.
-    /// Calls InitRegistry() if it has not already been called.
-    static void SetDefaultPrefix(const char* default_prefix);
-
-    /// 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(
-        std::unique_ptr<ResolverFactory> factory);
-  };
-
-  /// Checks whether the user input \a target is valid to create a resolver.
-  static bool IsValidTarget(absl::string_view 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.
-  /// If parsing fails or there is no factory for the URI's scheme,
-  /// 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 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,
-      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 std::string GetDefaultAuthority(absl::string_view target);
-
-  /// Returns \a target with the default prefix prepended, if needed.
-  static grpc_core::UniquePtr<char> AddDefaultPrefixIfNeeded(
-      const char* target);
-
-  /// Returns the resolver factory for \a scheme.
-  /// Caller does NOT own the return value.
-  static ResolverFactory* LookupResolverFactory(const char* scheme);
-};
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_REGISTRY_H */

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

@@ -1,189 +0,0 @@
-//
-// Copyright 2018 gRPC authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/ext/filters/client_channel/resolver_result_parsing.h"
-
-#include <ctype.h>
-#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>
-
-#include "src/core/ext/filters/client_channel/client_channel.h"
-#include "src/core/ext/filters/client_channel/lb_policy_registry.h"
-#include "src/core/ext/filters/client_channel/server_address.h"
-#include "src/core/lib/channel/channel_args.h"
-#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/json/json_util.h"
-#include "src/core/lib/uri/uri_parser.h"
-
-// As per the retry design, we do not allow more than 5 retry attempts.
-#define MAX_MAX_RETRY_ATTEMPTS 5
-
-namespace grpc_core {
-namespace internal {
-
-namespace {
-size_t g_client_channel_service_config_parser_index;
-}
-
-size_t ClientChannelServiceConfigParser::ParserIndex() {
-  return g_client_channel_service_config_parser_index;
-}
-
-void ClientChannelServiceConfigParser::Register() {
-  g_client_channel_service_config_parser_index =
-      ServiceConfigParser::RegisterParser(
-          absl::make_unique<ClientChannelServiceConfigParser>());
-}
-
-namespace {
-
-absl::optional<std::string> ParseHealthCheckConfig(const Json& field,
-                                                   grpc_error_handle* error) {
-  GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
-  if (field.type() != Json::Type::OBJECT) {
-    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:healthCheckConfig error:should be of type object");
-    return absl::nullopt;
-  }
-  std::vector<grpc_error_handle> error_list;
-  absl::optional<std::string> service_name;
-  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();
-    }
-  }
-  *error =
-      GRPC_ERROR_CREATE_FROM_VECTOR("field:healthCheckConfig", &error_list);
-  return service_name;
-}
-
-}  // namespace
-
-std::unique_ptr<ServiceConfigParser::ParsedConfig>
-ClientChannelServiceConfigParser::ParseGlobalParams(
-    const grpc_channel_args* /*args*/, const Json& json,
-    grpc_error_handle* error) {
-  GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
-  std::vector<grpc_error_handle> error_list;
-  // Parse LB config.
-  RefCountedPtr<LoadBalancingPolicy::Config> parsed_lb_config;
-  auto it = json.object_value().find("loadBalancingConfig");
-  if (it != json.object_value().end()) {
-    grpc_error_handle parse_error = GRPC_ERROR_NONE;
-    parsed_lb_config = LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
-        it->second, &parse_error);
-    if (parse_error != GRPC_ERROR_NONE) {
-      std::vector<grpc_error_handle> lb_errors;
-      lb_errors.push_back(parse_error);
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_VECTOR(
-          "field:loadBalancingConfig", &lb_errors));
-    }
-  }
-  // Parse deprecated LB policy.
-  std::string lb_policy_name;
-  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_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) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
-            absl::StrCat("field:loadBalancingPolicy error:", lb_policy_name,
-                         " requires a config. Please use loadBalancingConfig "
-                         "instead.")));
-      }
-    }
-  }
-  // Parse health check config.
-  absl::optional<std::string> health_check_service_name;
-  it = json.object_value().find("healthCheckConfig");
-  if (it != json.object_value().end()) {
-    grpc_error_handle 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 absl::make_unique<ClientChannelGlobalParsedConfig>(
-        std::move(parsed_lb_config), std::move(lb_policy_name),
-        std::move(health_check_service_name));
-  }
-  return nullptr;
-}
-
-std::unique_ptr<ServiceConfigParser::ParsedConfig>
-ClientChannelServiceConfigParser::ParsePerMethodParams(
-    const grpc_channel_args* /*args*/, const Json& json,
-    grpc_error_handle* error) {
-  GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
-  std::vector<grpc_error_handle> error_list;
-  // Parse waitForReady.
-  absl::optional<bool> wait_for_ready;
-  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.
-  grpc_millis timeout = 0;
-  ParseJsonObjectFieldAsDuration(json.object_value(), "timeout", &timeout,
-                                 &error_list, false);
-  // Return result.
-  *error = GRPC_ERROR_CREATE_FROM_VECTOR("Client channel parser", &error_list);
-  if (*error == GRPC_ERROR_NONE) {
-    return absl::make_unique<ClientChannelMethodParsedConfig>(timeout,
-                                                              wait_for_ready);
-  }
-  return nullptr;
-}
-
-}  // namespace internal
-}  // namespace grpc_core