grpc 1.46.3 → 1.53.1

data/src/core/lib/security/util/json_util.cc

@@ -1,30 +1,31 @@
-/*
- *
- * 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.
- *
- */
+//
+//
+// 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/lib/security/util/json_util.h"
 
-#include <string.h>
+#include <map>
+#include <string>
+#include <utility>
 
 #include "absl/strings/str_cat.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/iomgr/error.h"
@@ -34,22 +35,21 @@ const char* grpc_json_get_string_property(const grpc_core::Json& json,
                                           grpc_error_handle* error) {
   if (json.type() != grpc_core::Json::Type::OBJECT) {
     if (error != nullptr) {
-      *error =
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("JSON value is not an object");
+      *error = GRPC_ERROR_CREATE("JSON value is not an object");
     }
     return nullptr;
   }
   auto it = json.object_value().find(prop_name);
   if (it == json.object_value().end()) {
     if (error != nullptr) {
-      *error = GRPC_ERROR_CREATE_FROM_CPP_STRING(
+      *error = GRPC_ERROR_CREATE(
           absl::StrCat("Property ", prop_name, " not found in JSON object."));
     }
     return nullptr;
   }
   if (it->second.type() != grpc_core::Json::Type::STRING) {
     if (error != nullptr) {
-      *error = GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+      *error = GRPC_ERROR_CREATE(absl::StrCat(
           "Property ", prop_name, " n JSON object is not a string."));
     }
     return nullptr;
@@ -60,7 +60,7 @@ const char* grpc_json_get_string_property(const grpc_core::Json& json,
 bool grpc_copy_json_string_property(const grpc_core::Json& json,
                                     const char* prop_name,
                                     char** copied_value) {
-  grpc_error_handle error = GRPC_ERROR_NONE;
+  grpc_error_handle error;
   const char* prop_value =
       grpc_json_get_string_property(json, prop_name, &error);
   GRPC_LOG_IF_ERROR("Could not copy JSON property", error);

data/src/core/lib/security/util/json_util.h

@@ -1,28 +1,26 @@
-/*
- *
- * 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_LIB_SECURITY_UTIL_JSON_UTIL_H
-#define GRPC_CORE_LIB_SECURITY_UTIL_JSON_UTIL_H
+//
+//
+// 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_SRC_CORE_LIB_SECURITY_UTIL_JSON_UTIL_H
+#define GRPC_SRC_CORE_LIB_SECURITY_UTIL_JSON_UTIL_H
 
 #include <grpc/support/port_platform.h>
 
-#include <stdbool.h>
-
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/json/json.h"
 
@@ -42,4 +40,4 @@ const char* grpc_json_get_string_property(const grpc_core::Json& json,
 bool grpc_copy_json_string_property(const grpc_core::Json& json,
                                     const char* prop_name, char** copied_value);
 
-#endif /* GRPC_CORE_LIB_SECURITY_UTIL_JSON_UTIL_H */
+#endif  // GRPC_SRC_CORE_LIB_SECURITY_UTIL_JSON_UTIL_H

data/src/core/lib/service_config/service_config.h

@@ -14,23 +14,20 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_H
-#define GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_H
+#ifndef GRPC_SRC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_H
+#define GRPC_SRC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_H
 
 #include <grpc/support/port_platform.h>
 
-#include <unordered_map>
-#include <vector>
+#include <stddef.h>
 
-#include <grpc/impl/codegen/grpc_types.h>
-#include <grpc/support/string_util.h>
+#include "absl/strings/string_view.h"
 
+#include <grpc/slice.h>
+
+#include "src/core/lib/gpr/useful.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/service_config/service_config_parser.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:
@@ -56,12 +53,22 @@
 //   ]
 // }
 
+#define GRPC_ARG_SERVICE_CONFIG_OBJ "grpc.internal.service_config_obj"
+
 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.
+// interface required to be exposed as part of the resolver API.
 class ServiceConfig : public RefCounted<ServiceConfig> {
  public:
+  static absl::string_view ChannelArgName() {
+    return GRPC_ARG_SERVICE_CONFIG_OBJ;
+  }
+  static int ChannelArgsCompare(const ServiceConfig* a,
+                                const ServiceConfig* b) {
+    return QsortCompare(a, b);
+  }
+
   virtual absl::string_view json_string() const = 0;
 
   /// Retrieves the global parsed config at index \a index. The
@@ -79,4 +86,4 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_H */
+#endif  // GRPC_SRC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_H

data/src/core/lib/service_config/service_config_call_data.h

@@ -14,17 +14,21 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_CALL_DATA_H
-#define GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_CALL_DATA_H
+#ifndef GRPC_SRC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_CALL_DATA_H
+#define GRPC_SRC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_CALL_DATA_H
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
 #include <map>
+#include <memory>
+#include <utility>
 
 #include "absl/strings/string_view.h"
 
-#include "src/core/lib/channel/context.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/unique_type_name.h"
 #include "src/core/lib/service_config/service_config.h"
 #include "src/core/lib/service_config/service_config_parser.h"
 
@@ -36,7 +40,7 @@ namespace grpc_core {
 /// easily access method and global parameters for the call.
 class ServiceConfigCallData {
  public:
-  using CallAttributes = std::map<const char*, absl::string_view>;
+  using CallAttributes = std::map<UniqueTypeName, absl::string_view>;
 
   ServiceConfigCallData() : method_configs_(nullptr) {}
 
@@ -61,6 +65,12 @@ class ServiceConfigCallData {
 
   const CallAttributes& call_attributes() const { return call_attributes_; }
 
+  // Must be called when holding the call combiner (legacy filter) or from
+  // inside the activity (promise-based filter).
+  void SetCallAttribute(UniqueTypeName name, absl::string_view value) {
+    call_attributes_[name] = value;
+  }
+
  private:
   RefCountedPtr<ServiceConfig> service_config_;
   const ServiceConfigParser::ParsedConfigVector* method_configs_;
@@ -69,4 +79,4 @@ class ServiceConfigCallData {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_CALL_DATA_H */
+#endif  // GRPC_SRC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_CALL_DATA_H

data/src/core/lib/service_config/service_config_impl.cc

@@ -18,108 +18,139 @@
 
 #include "src/core/lib/service_config/service_config_impl.h"
 
+#include <string.h>
+
 #include <string>
+#include <utility>
 
+#include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
-
-#include <grpc/support/log.h>
+#include "absl/types/optional.h"
 
 #include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/json/json.h"
+#include "src/core/lib/json/json_args.h"
+#include "src/core/lib/json/json_object_loader.h"
 #include "src/core/lib/service_config/service_config_parser.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
 
 namespace grpc_core {
 
-RefCountedPtr<ServiceConfig> ServiceConfigImpl::Create(
-    const grpc_channel_args* args, absl::string_view json_string,
-    grpc_error_handle* error) {
-  GPR_DEBUG_ASSERT(error != nullptr);
-  Json json = Json::Parse(json_string, error);
-  if (*error != GRPC_ERROR_NONE) return nullptr;
-  return MakeRefCounted<ServiceConfigImpl>(args, std::string(json_string),
-                                           std::move(json), error);
-}
+namespace {
 
-ServiceConfigImpl::ServiceConfigImpl(const grpc_channel_args* args,
-                                     std::string json_string, Json json,
-                                     grpc_error_handle* error)
-    : json_string_(std::move(json_string)), json_(std::move(json)) {
-  GPR_DEBUG_ASSERT(error != nullptr);
-  if (json_.type() != Json::Type::OBJECT) {
-    *error =
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("JSON value is not an object");
-    return;
-  }
-  std::vector<grpc_error_handle> error_list;
-  grpc_error_handle global_error = GRPC_ERROR_NONE;
-  parsed_global_configs_ =
-      CoreConfiguration::Get().service_config_parser().ParseGlobalParameters(
-          args, json_, &global_error);
-  if (global_error != GRPC_ERROR_NONE) error_list.push_back(global_error);
-  grpc_error_handle local_error = ParsePerMethodParams(args);
-  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);
+struct MethodConfig {
+  struct Name {
+    absl::optional<std::string> service;
+    absl::optional<std::string> method;
+
+    static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
+      static const auto* loader = JsonObjectLoader<Name>()
+                                      .OptionalField("service", &Name::service)
+                                      .OptionalField("method", &Name::method)
+                                      .Finish();
+      return loader;
+    }
+
+    void JsonPostLoad(const Json&, const JsonArgs&, ValidationErrors* errors) {
+      if (!service.has_value() && method.has_value()) {
+        errors->AddError("method name populated without service name");
+      }
+    }
+
+    std::string Path() const {
+      if (!service.has_value() || service->empty()) return "";
+      return absl::StrCat("/", *service, "/",
+                          method.has_value() ? *method : "");
+    }
+  };
+
+  std::vector<Name> names;
+
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
+    static const auto* loader = JsonObjectLoader<MethodConfig>()
+                                    .OptionalField("name", &MethodConfig::names)
+                                    .Finish();
+    return loader;
   }
+};
+
+}  // namespace
+
+absl::StatusOr<RefCountedPtr<ServiceConfig>> ServiceConfigImpl::Create(
+    const ChannelArgs& args, absl::string_view json_string) {
+  auto json = Json::Parse(json_string);
+  if (!json.ok()) return json.status();
+  ValidationErrors errors;
+  auto service_config = Create(args, *json, json_string, &errors);
+  if (!errors.ok()) return errors.status("errors validating service config");
+  return service_config;
 }
 
-ServiceConfigImpl::~ServiceConfigImpl() {
-  for (auto& p : parsed_method_configs_map_) {
-    grpc_slice_unref_internal(p.first);
-  }
+RefCountedPtr<ServiceConfig> ServiceConfigImpl::Create(
+    const ChannelArgs& args, const Json& json, ValidationErrors* errors) {
+  return Create(args, json, json.Dump(), errors);
 }
 
-grpc_error_handle ServiceConfigImpl::ParseJsonMethodConfig(
-    const grpc_channel_args* args, const Json& json) {
-  std::vector<grpc_error_handle> error_list;
-  // Parse method config with each registered parser.
-  auto parsed_configs =
-      absl::make_unique<ServiceConfigParser::ParsedConfigVector>();
-  grpc_error_handle parser_error = GRPC_ERROR_NONE;
-  *parsed_configs =
-      CoreConfiguration::Get().service_config_parser().ParsePerMethodParameters(
-          args, json, &parser_error);
-  if (parser_error != GRPC_ERROR_NONE) {
-    error_list.push_back(parser_error);
+RefCountedPtr<ServiceConfig> ServiceConfigImpl::Create(
+    const ChannelArgs& args, const Json& json, absl::string_view json_string,
+    ValidationErrors* errors) {
+  if (json.type() != Json::Type::OBJECT) {
+    errors->AddError("is not an object");
+    return nullptr;
   }
-  parsed_method_config_vectors_storage_.push_back(std::move(parsed_configs));
-  const auto* vector_ptr = parsed_method_config_vectors_storage_.back().get();
-  // 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) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:name error:not of type Array"));
-      return GRPC_ERROR_CREATE_FROM_VECTOR("methodConfig", &error_list);
-    }
-    const Json::Array& name_array = it->second.array_value();
-    for (const Json& name : name_array) {
-      grpc_error_handle parse_error = GRPC_ERROR_NONE;
-      std::string path = ParseJsonMethodName(name, &parse_error);
-      if (parse_error != GRPC_ERROR_NONE) {
-        error_list.push_back(parse_error);
-      } else {
-        found_name = true;
+  auto service_config = MakeRefCounted<ServiceConfigImpl>();
+  service_config->json_string_ = std::string(json_string);
+  // Parse global parameters.
+  service_config->parsed_global_configs_ =
+      CoreConfiguration::Get().service_config_parser().ParseGlobalParameters(
+          args, json, errors);
+  // Parse per-method parameters.
+  auto method_configs = LoadJsonObjectField<std::vector<Json::Object>>(
+      json.object_value(), JsonArgs(), "methodConfig", errors,
+      /*required=*/false);
+  if (method_configs.has_value()) {
+    service_config->parsed_method_config_vectors_storage_.reserve(
+        method_configs->size());
+    for (size_t i = 0; i < method_configs->size(); ++i) {
+      const Json::Object& method_config_json = (*method_configs)[i];
+      ValidationErrors::ScopedField field(
+          errors, absl::StrCat(".methodConfig[", i, "]"));
+      // Have each parser read this method config.
+      auto parsed_configs =
+          CoreConfiguration::Get()
+              .service_config_parser()
+              .ParsePerMethodParameters(args, method_config_json, errors);
+      // Store the parsed configs.
+      service_config->parsed_method_config_vectors_storage_.push_back(
+          std::move(parsed_configs));
+      const ServiceConfigParser::ParsedConfigVector* vector_ptr =
+          &service_config->parsed_method_config_vectors_storage_.back();
+      // Parse the names.
+      auto method_config =
+          LoadFromJson<MethodConfig>(method_config_json, JsonArgs(), errors);
+      for (size_t j = 0; j < method_config.names.size(); ++j) {
+        ValidationErrors::ScopedField field(errors,
+                                            absl::StrCat(".name[", j, "]"));
+        std::string path = method_config.names[j].Path();
         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"));
+          if (service_config->default_method_config_vector_ != nullptr) {
+            errors->AddError("duplicate default method config");
           }
-          default_method_config_vector_ = vector_ptr;
+          service_config->default_method_config_vector_ = vector_ptr;
         } else {
-          grpc_slice key = grpc_slice_from_copied_string(path.c_str());
+          grpc_slice key = grpc_slice_from_cpp_string(std::move(path));
           // 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];
+          auto& value = service_config->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"));
+            errors->AddError(absl::StrCat("multiple method configs for path ",
+                                          StringViewFromSlice(key)));
             // The map entry already existed, so we need to unref the
             // key we just created.
-            grpc_slice_unref_internal(key);
+            CSliceUnref(key);
           } else {
             value = vector_ptr;
           }
@@ -127,83 +158,13 @@ grpc_error_handle ServiceConfigImpl::ParseJsonMethodConfig(
       }
     }
   }
-  if (!found_name) {
-    parsed_method_config_vectors_storage_.pop_back();
-  }
-  return GRPC_ERROR_CREATE_FROM_VECTOR("methodConfig", &error_list);
-}
-
-grpc_error_handle ServiceConfigImpl::ParsePerMethodParams(
-    const grpc_channel_args* args) {
-  std::vector<grpc_error_handle> error_list;
-  auto it = json_.object_value().find("methodConfig");
-  if (it != json_.object_value().end()) {
-    if (it->second.type() != Json::Type::ARRAY) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:methodConfig error:not of type Array"));
-    }
-    for (const Json& method_config : it->second.array_value()) {
-      if (method_config.type() != Json::Type::OBJECT) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:methodConfig error:not of type Object"));
-        continue;
-      }
-      grpc_error_handle error = ParseJsonMethodConfig(args, method_config);
-      if (error != GRPC_ERROR_NONE) {
-        error_list.push_back(error);
-      }
-    }
-  }
-  return GRPC_ERROR_CREATE_FROM_VECTOR("Method Params", &error_list);
+  return service_config;
 }
 
-std::string ServiceConfigImpl::ParseJsonMethodName(const Json& json,
-                                                   grpc_error_handle* error) {
-  if (json.type() != Json::Type::OBJECT) {
-    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:name error:type is not object");
-    return "";
-  }
-  // Find service name.
-  const std::string* service_name = nullptr;
-  auto it = json.object_value().find("service");
-  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 std::string* method_name = nullptr;
-  // Find method name.
-  it = json.object_value().find("method");
-  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 "";
-    }
-    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:method name populated without service name");
-    }
-    return "";
+ServiceConfigImpl::~ServiceConfigImpl() {
+  for (auto& p : parsed_method_configs_map_) {
+    CSliceUnref(p.first);
   }
-  // Construct path.
-  return absl::StrCat("/", *service_name, "/",
-                      method_name == nullptr ? "" : *method_name);
 }
 
 const ServiceConfigParser::ParsedConfigVector*

data/src/core/lib/service_config/service_config_impl.h

@@ -14,20 +14,27 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_IMPL_H
-#define GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_IMPL_H
+#ifndef GRPC_SRC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_IMPL_H
+#define GRPC_SRC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_IMPL_H
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
+#include <memory>
+#include <string>
 #include <unordered_map>
 #include <vector>
 
-#include <grpc/impl/codegen/grpc_types.h>
-#include <grpc/support/string_util.h>
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/slice.h>
+#include <grpc/support/log.h>
 
-#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/service_config/service_config.h"
 #include "src/core/lib/service_config/service_config_parser.h"
@@ -62,13 +69,18 @@ namespace grpc_core {
 class ServiceConfigImpl final : public ServiceConfig {
  public:
   /// Creates a new service config from parsing \a json_string.
-  /// Returns null on parse error.
-  static RefCountedPtr<ServiceConfig> Create(const grpc_channel_args* args,
+  static absl::StatusOr<RefCountedPtr<ServiceConfig>> Create(
+      const ChannelArgs& args, absl::string_view json_string);
+
+  // Alternate forms that are useful in edge cases.
+  static RefCountedPtr<ServiceConfig> Create(const ChannelArgs& args,
+                                             const Json& json,
                                              absl::string_view json_string,
-                                             grpc_error_handle* error);
+                                             ValidationErrors* errors);
+  static RefCountedPtr<ServiceConfig> Create(const ChannelArgs& args,
+                                             const Json& json,
+                                             ValidationErrors* errors);
 
-  ServiceConfigImpl(const grpc_channel_args* args, std::string json_string,
-                    Json json, grpc_error_handle* error);
   ~ServiceConfigImpl() override;
 
   absl::string_view json_string() const override { return json_string_; }
@@ -89,21 +101,10 @@ class ServiceConfigImpl final : public ServiceConfig {
       const grpc_slice& path) const override;
 
  private:
-  // Helper functions for parsing the method configs.
-  grpc_error_handle ParsePerMethodParams(const grpc_channel_args* args);
-  grpc_error_handle ParseJsonMethodConfig(const grpc_channel_args* args,
-                                          const Json& json);
-
-  // 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_handle* error);
-
   std::string json_string_;
   Json json_;
 
-  std::vector<std::unique_ptr<ServiceConfigParser::ParsedConfig>>
-      parsed_global_configs_;
+  ServiceConfigParser::ParsedConfigVector 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.
@@ -114,12 +115,11 @@ class ServiceConfigImpl final : public ServiceConfig {
   const ServiceConfigParser::ParsedConfigVector* default_method_config_vector_ =
       nullptr;
   // Storage for all the vectors that are being used in
-  // parsed_method_configs_table_.
-  absl::InlinedVector<std::unique_ptr<ServiceConfigParser::ParsedConfigVector>,
-                      32>
+  // parsed_method_configs_map_ and default_method_config_vector_.
+  std::vector<ServiceConfigParser::ParsedConfigVector>
       parsed_method_config_vectors_storage_;
 };
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_IMPL_H */
+#endif  // GRPC_SRC_CORE_LIB_SERVICE_CONFIG_SERVICE_CONFIG_IMPL_H