grpc 1.28.0 → 1.30.0

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

@@ -21,13 +21,14 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/container/inlined_vector.h"
+
 #include "src/core/ext/filters/client_channel/lb_policy.h"
 #include "src/core/ext/filters/client_channel/lb_policy_factory.h"
 #include "src/core/ext/filters/client_channel/resolver.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gprpp/inlined_vector.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -80,7 +81,7 @@ class ResolvingLoadBalancingPolicy : public LoadBalancingPolicy {
   void ResetBackoffLocked() override;
 
  private:
-  using TraceStringVector = InlinedVector<char*, 3>;
+  using TraceStringVector = absl::InlinedVector<const char*, 3>;
 
   class ResolverResultHandler;
   class ResolvingControlHelper;
@@ -98,7 +99,7 @@ class ResolvingLoadBalancingPolicy : public LoadBalancingPolicy {
   void MaybeAddTraceMessagesForAddressChangesLocked(
       bool resolution_contains_addresses, TraceStringVector* trace_strings);
   void ConcatenateAndAddChannelTraceLocked(
-      TraceStringVector* trace_strings) const;
+      const TraceStringVector& trace_strings) const;
   void OnResolverResultChangedLocked(Resolver::Result result);
 
   // Passed in from caller at construction time.

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

@@ -37,15 +37,12 @@ ServerAddress::ServerAddress(const void* address, size_t address_len,
   address_.len = static_cast<socklen_t>(address_len);
 }
 
-bool ServerAddress::operator==(const ServerAddress& other) const {
-  return address_.len == other.address_.len &&
-         memcmp(address_.addr, other.address_.addr, address_.len) == 0 &&
-         grpc_channel_args_compare(args_, other.args_) == 0;
-}
-
-bool ServerAddress::IsBalancer() const {
-  return grpc_channel_arg_get_bool(
-      grpc_channel_args_find(args_, GRPC_ARG_ADDRESS_IS_BALANCER), false);
+int ServerAddress::Cmp(const ServerAddress& other) const {
+  if (address_.len > other.address_.len) return 1;
+  if (address_.len < other.address_.len) return -1;
+  int retval = memcmp(address_.addr, other.address_.addr, address_.len);
+  if (retval != 0) return retval;
+  return grpc_channel_args_compare(args_, other.args_);
 }
 
 }  // namespace grpc_core

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

@@ -21,17 +21,11 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/container/inlined_vector.h"
+
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gprpp/inlined_vector.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 
-// Channel arg key for a bool indicating whether an address is a grpclb
-// load balancer (as opposed to a backend).
-#define GRPC_ARG_ADDRESS_IS_BALANCER "grpc.address_is_balancer"
-
-// Channel arg key for a string indicating an address's balancer name.
-#define GRPC_ARG_ADDRESS_BALANCER_NAME "grpc.address_balancer_name"
-
 namespace grpc_core {
 
 //
@@ -73,13 +67,13 @@ class ServerAddress {
     return *this;
   }
 
-  bool operator==(const ServerAddress& other) const;
+  bool operator==(const ServerAddress& other) const { return Cmp(other) == 0; }
+
+  int Cmp(const ServerAddress& other) const;
 
   const grpc_resolved_address& address() const { return address_; }
   const grpc_channel_args* args() const { return args_; }
 
-  bool IsBalancer() const;
-
  private:
   grpc_resolved_address address_;
   grpc_channel_args* args_;
@@ -89,7 +83,7 @@ class ServerAddress {
 // ServerAddressList
 //
 
-typedef InlinedVector<ServerAddress, 1> ServerAddressList;
+typedef absl::InlinedVector<ServerAddress, 1> ServerAddressList;
 
 }  // namespace grpc_core
 

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

@@ -18,30 +18,20 @@
 
 #include "src/core/ext/filters/client_channel/service_config.h"
 
-#include <string.h>
+#include <string>
+
+#include "absl/strings/str_cat.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
-#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 
-#include "src/core/lib/gpr/string.h"
+#include "src/core/ext/filters/client_channel/service_config_parser.h"
 #include "src/core/lib/json/json.h"
-#include "src/core/lib/slice/slice_hash_table.h"
 #include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_string_helpers.h"
 
 namespace grpc_core {
 
-namespace {
-typedef InlinedVector<std::unique_ptr<ServiceConfig::Parser>,
-                      ServiceConfig::kNumPreallocatedParsers>
-    ServiceConfigParserList;
-ServiceConfigParserList* g_registered_parsers;
-}  // namespace
-
-RefCountedPtr<ServiceConfig> ServiceConfig::Create(StringView json_string,
-                                                   grpc_error** error) {
+RefCountedPtr<ServiceConfig> ServiceConfig::Create(
+    absl::string_view json_string, grpc_error** error) {
   GPR_DEBUG_ASSERT(error != nullptr);
   Json json = Json::Parse(json_string, error);
   if (*error != GRPC_ERROR_NONE) return nullptr;
@@ -59,57 +49,40 @@ ServiceConfig::ServiceConfig(std::string json_string, Json json,
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("JSON value is not an object");
     return;
   }
-  grpc_error* error_list[2];
-  int error_count = 0;
-  grpc_error* global_error = ParseGlobalParams();
+  std::vector<grpc_error*> error_list;
+  grpc_error* global_error = GRPC_ERROR_NONE;
+  parsed_global_configs_ =
+      ServiceConfigParser::ParseGlobalParameters(json_, &global_error);
+  if (global_error != GRPC_ERROR_NONE) error_list.push_back(global_error);
   grpc_error* local_error = ParsePerMethodParams();
-  if (global_error != GRPC_ERROR_NONE) {
-    error_list[error_count++] = global_error;
-  }
-  if (local_error != GRPC_ERROR_NONE) {
-    error_list[error_count++] = local_error;
-  }
-  if (error_count > 0) {
-    *error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-        "Service config parsing error", error_list, error_count);
-    GRPC_ERROR_UNREF(global_error);
-    GRPC_ERROR_UNREF(local_error);
+  if (local_error != GRPC_ERROR_NONE) error_list.push_back(local_error);
+  if (!error_list.empty()) {
+    *error = GRPC_ERROR_CREATE_FROM_VECTOR("Service config parsing error",
+                                           &error_list);
   }
 }
 
-grpc_error* ServiceConfig::ParseGlobalParams() {
-  std::vector<grpc_error*> error_list;
-  for (size_t i = 0; i < g_registered_parsers->size(); i++) {
-    grpc_error* parser_error = GRPC_ERROR_NONE;
-    auto parsed_obj =
-        (*g_registered_parsers)[i]->ParseGlobalParams(json_, &parser_error);
-    if (parser_error != GRPC_ERROR_NONE) {
-      error_list.push_back(parser_error);
-    }
-    parsed_global_configs_.push_back(std::move(parsed_obj));
+ServiceConfig::~ServiceConfig() {
+  for (auto& p : parsed_method_configs_map_) {
+    grpc_slice_unref_internal(p.first);
   }
-  return GRPC_ERROR_CREATE_FROM_VECTOR("Global Params", &error_list);
 }
 
-grpc_error* ServiceConfig::ParseJsonMethodConfigToServiceConfigVectorTable(
-    const Json& json,
-    InlinedVector<SliceHashTable<const ParsedConfigVector*>::Entry, 10>*
-        entries) {
-  auto objs_vector = absl::make_unique<ParsedConfigVector>();
-  InlinedVector<grpc_error*, 4> error_list;
-  for (size_t i = 0; i < g_registered_parsers->size(); i++) {
-    grpc_error* parser_error = GRPC_ERROR_NONE;
-    auto parsed_obj =
-        (*g_registered_parsers)[i]->ParsePerMethodParams(json, &parser_error);
-    if (parser_error != GRPC_ERROR_NONE) {
-      error_list.push_back(parser_error);
-    }
-    objs_vector->push_back(std::move(parsed_obj));
-  }
-  parsed_method_config_vectors_storage_.push_back(std::move(objs_vector));
+grpc_error* ServiceConfig::ParseJsonMethodConfig(const Json& json) {
+  std::vector<grpc_error*> error_list;
+  // Parse method config with each registered parser.
+  auto parsed_configs =
+      absl::make_unique<ServiceConfigParser::ParsedConfigVector>();
+  grpc_error* parser_error = GRPC_ERROR_NONE;
+  *parsed_configs =
+      ServiceConfigParser::ParsePerMethodParameters(json, &parser_error);
+  if (parser_error != GRPC_ERROR_NONE) {
+    error_list.push_back(parser_error);
+  }
+  parsed_method_config_vectors_storage_.push_back(std::move(parsed_configs));
   const auto* vector_ptr = parsed_method_config_vectors_storage_.back().get();
-  // Construct list of paths.
-  InlinedVector<UniquePtr<char>, 10> paths;
+  // Add an entry for each path.
+  bool found_name = false;
   auto it = json.object_value().find("name");
   if (it != json.object_value().end()) {
     if (it->second.type() != Json::Type::ARRAY) {
@@ -120,29 +93,42 @@ grpc_error* ServiceConfig::ParseJsonMethodConfigToServiceConfigVectorTable(
     const Json::Array& name_array = it->second.array_value();
     for (const Json& name : name_array) {
       grpc_error* parse_error = GRPC_ERROR_NONE;
-      UniquePtr<char> path = ParseJsonMethodName(name, &parse_error);
-      if (path == nullptr) {
+      std::string path = ParseJsonMethodName(name, &parse_error);
+      if (parse_error != GRPC_ERROR_NONE) {
         error_list.push_back(parse_error);
       } else {
-        GPR_DEBUG_ASSERT(parse_error == GRPC_ERROR_NONE);
-        paths.push_back(std::move(path));
+        found_name = true;
+        if (path.empty()) {
+          if (default_method_config_vector_ != nullptr) {
+            error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                "field:name error:multiple default method configs"));
+          }
+          default_method_config_vector_ = vector_ptr;
+        } else {
+          grpc_slice key = grpc_slice_from_copied_string(path.c_str());
+          // If the key is not already present in the map, this will
+          // store a ref to the key in the map.
+          auto& value = parsed_method_configs_map_[key];
+          if (value != nullptr) {
+            error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                "field:name error:multiple method configs with same name"));
+            // The map entry already existed, so we need to unref the
+            // key we just created.
+            grpc_slice_unref_internal(key);
+          } else {
+            value = vector_ptr;
+          }
+        }
       }
     }
   }
-  if (paths.size() == 0) {
-    error_list.push_back(
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("No names specified"));
-  }
-  // Add entry for each path.
-  for (size_t i = 0; i < paths.size(); ++i) {
-    entries->push_back(
-        {grpc_slice_from_copied_string(paths[i].get()), vector_ptr});
+  if (!found_name) {
+    parsed_method_config_vectors_storage_.pop_back();
   }
   return GRPC_ERROR_CREATE_FROM_VECTOR("methodConfig", &error_list);
 }
 
 grpc_error* ServiceConfig::ParsePerMethodParams() {
-  InlinedVector<SliceHashTable<const ParsedConfigVector*>::Entry, 10> entries;
   std::vector<grpc_error*> error_list;
   auto it = json_.object_value().find("methodConfig");
   if (it != json_.object_value().end()) {
@@ -156,106 +142,80 @@ grpc_error* ServiceConfig::ParsePerMethodParams() {
             "field:methodConfig error:not of type Object"));
         continue;
       }
-      grpc_error* error = ParseJsonMethodConfigToServiceConfigVectorTable(
-          method_config, &entries);
+      grpc_error* error = ParseJsonMethodConfig(method_config);
       if (error != GRPC_ERROR_NONE) {
         error_list.push_back(error);
       }
     }
   }
-  if (!entries.empty()) {
-    parsed_method_configs_table_ =
-        SliceHashTable<const ParsedConfigVector*>::Create(
-            entries.size(), entries.data(), nullptr);
-  }
   return GRPC_ERROR_CREATE_FROM_VECTOR("Method Params", &error_list);
 }
 
-UniquePtr<char> ServiceConfig::ParseJsonMethodName(const Json& json,
-                                                   grpc_error** error) {
+std::string ServiceConfig::ParseJsonMethodName(const Json& json,
+                                               grpc_error** error) {
   if (json.type() != Json::Type::OBJECT) {
     *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "field:name error:type is not object");
-    return nullptr;
+    return "";
   }
   // Find service name.
+  const std::string* service_name = nullptr;
   auto it = json.object_value().find("service");
-  if (it == json.object_value().end()) {
-    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:name error: field:service error:not found");
-    return nullptr;  // Required field.
-  }
-  if (it->second.type() != Json::Type::STRING) {
-    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:name error: field:service error:not of type string");
-    return nullptr;
-  }
-  if (it->second.string_value().empty()) {
-    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:name error: field:service error:empty value");
-    return nullptr;
+  if (it != json.object_value().end() &&
+      it->second.type() != Json::Type::JSON_NULL) {
+    if (it->second.type() != Json::Type::STRING) {
+      *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:name error: field:service error:not of type string");
+      return "";
+    }
+    if (!it->second.string_value().empty()) {
+      service_name = &it->second.string_value();
+    }
   }
-  const char* service_name = it->second.string_value().c_str();
-  const char* method_name = nullptr;
+  const std::string* method_name = nullptr;
   // Find method name.
   it = json.object_value().find("method");
-  if (it != json.object_value().end()) {
+  if (it != json.object_value().end() &&
+      it->second.type() != Json::Type::JSON_NULL) {
     if (it->second.type() != Json::Type::STRING) {
       *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "field:name error: field:method error:not of type string");
-      return nullptr;
+      return "";
     }
-    if (it->second.string_value().empty()) {
+    if (!it->second.string_value().empty()) {
+      method_name = &it->second.string_value();
+    }
+  }
+  // If neither service nor method are specified, it's the default.
+  // Method name may not be specified without service name.
+  if (service_name == nullptr) {
+    if (method_name != nullptr) {
       *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:name error: field:method error:empty value");
-      return nullptr;
+          "field:name error:method name populated without service name");
     }
-    method_name = it->second.string_value().c_str();
+    return "";
   }
-  char* path;
-  gpr_asprintf(&path, "/%s/%s", service_name,
-               method_name == nullptr ? "" : method_name);
-  return grpc_core::UniquePtr<char>(path);
+  // Construct path.
+  return absl::StrCat("/", *service_name, "/",
+                      method_name == nullptr ? "" : *method_name);
 }
 
-const ServiceConfig::ParsedConfigVector*
-ServiceConfig::GetMethodParsedConfigVector(const grpc_slice& path) {
-  if (parsed_method_configs_table_.get() == nullptr) {
-    return nullptr;
-  }
-  const auto* value = parsed_method_configs_table_->Get(path);
+const ServiceConfigParser::ParsedConfigVector*
+ServiceConfig::GetMethodParsedConfigVector(const grpc_slice& path) const {
+  // Try looking up the full path in the map.
+  auto it = parsed_method_configs_map_.find(path);
+  if (it != parsed_method_configs_map_.end()) return it->second;
   // If we didn't find a match for the path, try looking for a wildcard
   // entry (i.e., change "/service/method" to "/service/").
-  if (value == nullptr) {
-    char* path_str = grpc_slice_to_c_string(path);
-    const char* sep = strrchr(path_str, '/') + 1;
-    const size_t len = (size_t)(sep - path_str);
-    char* buf = (char*)gpr_malloc(len + 1);  // trailing NUL
-    memcpy(buf, path_str, len);
-    buf[len] = '\0';
-    grpc_slice wildcard_path = grpc_slice_from_copied_string(buf);
-    gpr_free(buf);
-    value = parsed_method_configs_table_->Get(wildcard_path);
-    grpc_slice_unref_internal(wildcard_path);
-    gpr_free(path_str);
-    if (value == nullptr) return nullptr;
-  }
-  return *value;
-}
-
-size_t ServiceConfig::RegisterParser(std::unique_ptr<Parser> parser) {
-  g_registered_parsers->push_back(std::move(parser));
-  return g_registered_parsers->size() - 1;
-}
-
-void ServiceConfig::Init() {
-  GPR_ASSERT(g_registered_parsers == nullptr);
-  g_registered_parsers = new ServiceConfigParserList();
-}
-
-void ServiceConfig::Shutdown() {
-  delete g_registered_parsers;
-  g_registered_parsers = nullptr;
+  UniquePtr<char> path_str(grpc_slice_to_c_string(path));
+  char* sep = strrchr(path_str.get(), '/') + 1;
+  if (sep == nullptr) return nullptr;  // Shouldn't ever happen.
+  *sep = '\0';
+  grpc_slice wildcard_path = grpc_slice_from_static_string(path_str.get());
+  it = parsed_method_configs_map_.find(wildcard_path);
+  if (it != parsed_method_configs_map_.end()) return it->second;
+  // Try default method config, if set.
+  return default_method_config_vector_;
 }
 
 }  // namespace grpc_core

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

@@ -19,15 +19,19 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <unordered_map>
+
+#include "absl/container/inlined_vector.h"
+
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/gprpp/inlined_vector.h"
+#include "src/core/ext/filters/client_channel/service_config_parser.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/json/json.h"
-#include "src/core/lib/slice/slice_hash_table.h"
+#include "src/core/lib/slice/slice_internal.h"
 
 // The main purpose of the code here is to parse the service config in
 // JSON form, which will look like this:
@@ -55,87 +59,24 @@
 
 namespace grpc_core {
 
+// TODO(roth): Consider stripping this down further to the completely minimal
+// interface requied to be exposed as part of the resolver API.
 class ServiceConfig : public RefCounted<ServiceConfig> {
  public:
-  /// This is the base class that all service config parsers MUST use to store
-  /// parsed service config data.
-  class ParsedConfig {
-   public:
-    virtual ~ParsedConfig() = default;
-  };
-
-  /// This is the base class that all service config parsers should derive from.
-  class Parser {
-   public:
-    virtual ~Parser() = default;
-
-    virtual std::unique_ptr<ParsedConfig> ParseGlobalParams(
-        const Json& /* json */, grpc_error** error) {
-      // Avoid unused parameter warning on debug-only parameter
-      (void)error;
-      GPR_DEBUG_ASSERT(error != nullptr);
-      return nullptr;
-    }
-
-    virtual std::unique_ptr<ParsedConfig> ParsePerMethodParams(
-        const Json& /* json */, grpc_error** error) {
-      // Avoid unused parameter warning on debug-only parameter
-      (void)error;
-      GPR_DEBUG_ASSERT(error != nullptr);
-      return nullptr;
-    }
-  };
-
-  static constexpr int kNumPreallocatedParsers = 4;
-  typedef InlinedVector<std::unique_ptr<ParsedConfig>, kNumPreallocatedParsers>
-      ParsedConfigVector;
-
-  /// When a service config is applied to a call in the client_channel_filter,
-  /// we create an instance of this object and store it in the call_data for
-  /// client_channel. A pointer to this object is also stored in the
-  /// call_context, so that future filters can easily access method and global
-  /// parameters for the call.
-  class CallData {
-   public:
-    CallData() = default;
-    CallData(RefCountedPtr<ServiceConfig> svc_cfg, const grpc_slice& path)
-        : service_config_(std::move(svc_cfg)) {
-      if (service_config_ != nullptr) {
-        method_params_vector_ =
-            service_config_->GetMethodParsedConfigVector(path);
-      }
-    }
-
-    ServiceConfig* service_config() { return service_config_.get(); }
-
-    ParsedConfig* GetMethodParsedConfig(size_t index) const {
-      return method_params_vector_ != nullptr
-                 ? (*method_params_vector_)[index].get()
-                 : nullptr;
-    }
-
-    ParsedConfig* GetGlobalParsedConfig(size_t index) const {
-      return service_config_->GetGlobalParsedConfig(index);
-    }
-
-   private:
-    RefCountedPtr<ServiceConfig> service_config_;
-    const ParsedConfigVector* method_params_vector_ = nullptr;
-  };
-
   /// Creates a new service config from parsing \a json_string.
   /// Returns null on parse error.
-  static RefCountedPtr<ServiceConfig> Create(StringView json_string,
+  static RefCountedPtr<ServiceConfig> Create(absl::string_view json_string,
                                              grpc_error** error);
 
   ServiceConfig(std::string json_string, Json json, grpc_error** error);
+  ~ServiceConfig();
 
   const std::string& json_string() const { return json_string_; }
 
   /// Retrieves the global parsed config at index \a index. The
   /// lifetime of the returned object is tied to the lifetime of the
   /// ServiceConfig object.
-  ParsedConfig* GetGlobalParsedConfig(size_t index) {
+  ServiceConfigParser::ParsedConfig* GetGlobalParsedConfig(size_t index) {
     GPR_DEBUG_ASSERT(index < parsed_global_configs_.size());
     return parsed_global_configs_[index].get();
   }
@@ -143,48 +84,37 @@ class ServiceConfig : public RefCounted {
   /// Retrieves the vector of parsed configs for the method identified
   /// by \a path.  The lifetime of the returned vector and contained objects
   /// is tied to the lifetime of the ServiceConfig object.
-  const ParsedConfigVector* GetMethodParsedConfigVector(const grpc_slice& path);
-
-  /// Globally register a service config parser. On successful registration, it
-  /// returns the index at which the parser was registered. On failure, -1 is
-  /// returned. Each new service config update will go through all the
-  /// registered parser. Each parser is responsible for reading the service
-  /// config json and returning a parsed config. This parsed config can later be
-  /// retrieved using the same index that was returned at registration time.
-  static size_t RegisterParser(std::unique_ptr<Parser> parser);
-
-  static void Init();
-
-  static void Shutdown();
+  const ServiceConfigParser::ParsedConfigVector* GetMethodParsedConfigVector(
+      const grpc_slice& path) const;
 
  private:
-  // Helper functions to parse the service config
-  grpc_error* ParseGlobalParams();
+  // Helper functions for parsing the method configs.
   grpc_error* ParsePerMethodParams();
+  grpc_error* ParseJsonMethodConfig(const Json& json);
 
-  // Returns a path string for the JSON name object specified by \a json.
-  // Returns null on error, and stores error in \a error.
-  static UniquePtr<char> ParseJsonMethodName(const Json& json,
-                                             grpc_error** error);
-
-  grpc_error* ParseJsonMethodConfigToServiceConfigVectorTable(
-      const Json& json,
-      InlinedVector<SliceHashTable<const ParsedConfigVector*>::Entry, 10>*
-          entries);
+  // Returns a path string for the JSON name object specified by json.
+  // Sets *error on error.
+  static std::string ParseJsonMethodName(const Json& json, grpc_error** error);
 
   std::string json_string_;
   Json json_;
 
-  InlinedVector<std::unique_ptr<ParsedConfig>, kNumPreallocatedParsers>
+  absl::InlinedVector<std::unique_ptr<ServiceConfigParser::ParsedConfig>,
+                      ServiceConfigParser::kNumPreallocatedParsers>
       parsed_global_configs_;
   // A map from the method name to the parsed config vector. Note that we are
   // using a raw pointer and not a unique pointer so that we can use the same
   // vector for multiple names.
-  RefCountedPtr<SliceHashTable<const ParsedConfigVector*>>
-      parsed_method_configs_table_;
+  std::unordered_map<grpc_slice, const ServiceConfigParser::ParsedConfigVector*,
+                     SliceHash>
+      parsed_method_configs_map_;
+  // Default method config.
+  const ServiceConfigParser::ParsedConfigVector* default_method_config_vector_ =
+      nullptr;
   // Storage for all the vectors that are being used in
   // parsed_method_configs_table_.
-  InlinedVector<std::unique_ptr<ParsedConfigVector>, 32>
+  absl::InlinedVector<std::unique_ptr<ServiceConfigParser::ParsedConfigVector>,
+                      32>
       parsed_method_config_vectors_storage_;
 };