grpc 1.47.0 → 1.49.0.pre1

data/src/core/lib/security/transport/server_auth_filter.cc

@@ -20,13 +20,35 @@
 
 #include <string.h>
 
+#include <algorithm>
+#include <new>
+
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/slice.h>
+#include <grpc/status.h>
 #include <grpc/support/alloc.h>
+#include <grpc/support/atm.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/channel/channel_fwd.h"
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/context.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/iomgr/call_combiner.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/security/context/security_context.h"
 #include "src/core/lib/security/credentials/credentials.h"
-#include "src/core/lib/security/transport/auth_filters.h"
+#include "src/core/lib/security/transport/auth_filters.h"  // IWYU pragma: keep
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_refcount.h"
+#include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/transport.h"
 
 static void recv_initial_metadata_ready(void* arg, grpc_error_handle error);
 static void recv_trailing_metadata_ready(void* user_data,
@@ -149,7 +171,7 @@ static void on_md_processing_done_inner(grpc_call_element* elem,
             "response_md in auth metadata processing not supported for now. "
             "Ignoring...");
   }
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     for (size_t i = 0; i < num_consumed_md; i++) {
       batch->payload->recv_initial_metadata.recv_initial_metadata->Remove(
           grpc_core::StringViewFromSlice(consumed_md[i].key));
@@ -204,7 +226,7 @@ static void cancel_call(void* arg, grpc_error_handle error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   // If the result was not already processed, invoke the callback now.
-  if (error != GRPC_ERROR_NONE &&
+  if (!GRPC_ERROR_IS_NONE(error) &&
       gpr_atm_full_cas(&calld->state, static_cast<gpr_atm>(STATE_INIT),
                        static_cast<gpr_atm>(STATE_CANCELLED))) {
     on_md_processing_done_inner(elem, nullptr, 0, nullptr, 0,
@@ -218,7 +240,7 @@ static void recv_initial_metadata_ready(void* arg, grpc_error_handle error) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   grpc_transport_stream_op_batch* batch = calld->recv_initial_metadata_batch;
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     if (chand->creds != nullptr &&
         chand->creds->auth_metadata_processor().process != nullptr) {
       // We're calling out to the application, so we need to make sure

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

@@ -20,11 +20,12 @@
 
 #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"

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

@@ -21,8 +21,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdbool.h>
-
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/json/json.h"
 

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

@@ -25,6 +25,7 @@
 
 #include <grpc/slice.h>
 
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/service_config/service_config_parser.h"
 
@@ -52,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.
 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

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

@@ -28,6 +28,7 @@
 #include "absl/strings/string_view.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"
 
@@ -39,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) {}
 

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

@@ -25,7 +25,10 @@
 #include <utility>
 
 #include "absl/memory/memory.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
 
 #include <grpc/support/log.h>
 
@@ -38,37 +41,40 @@
 
 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);
+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();
+  absl::Status status;
+  auto service_config = MakeRefCounted<ServiceConfigImpl>(
+      args, std::string(json_string), std::move(*json), &status);
+  if (!status.ok()) return status;
+  return service_config;
 }
 
-ServiceConfigImpl::ServiceConfigImpl(const grpc_channel_args* args,
+ServiceConfigImpl::ServiceConfigImpl(const ChannelArgs& args,
                                      std::string json_string, Json json,
-                                     grpc_error_handle* error)
+                                     absl::Status* status)
     : json_string_(std::move(json_string)), json_(std::move(json)) {
-  GPR_DEBUG_ASSERT(error != nullptr);
+  GPR_DEBUG_ASSERT(status != nullptr);
   if (json_.type() != Json::Type::OBJECT) {
-    *error =
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("JSON value is not an object");
+    *status = absl::InvalidArgumentError("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_ =
+  std::vector<std::string> errors;
+  auto 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);
+          args, json_);
+  if (!parsed_global_configs.ok()) {
+    errors.emplace_back(parsed_global_configs.status().message());
+  } else {
+    parsed_global_configs_ = std::move(*parsed_global_configs);
+  }
+  absl::Status local_status = ParsePerMethodParams(args);
+  if (!local_status.ok()) errors.emplace_back(local_status.message());
+  if (!errors.empty()) {
+    *status = absl::InvalidArgumentError(absl::StrCat(
+        "Service config parsing errors: [", absl::StrJoin(errors, "; "), "]"));
   }
 }
 
@@ -78,98 +84,95 @@ ServiceConfigImpl::~ServiceConfigImpl() {
   }
 }
 
-grpc_error_handle ServiceConfigImpl::ParseJsonMethodConfig(
-    const grpc_channel_args* args, const Json& json) {
-  std::vector<grpc_error_handle> error_list;
+absl::Status ServiceConfigImpl::ParseJsonMethodConfig(const ChannelArgs& args,
+                                                      const Json& json,
+                                                      size_t index) {
+  std::vector<std::string> errors;
+  const ServiceConfigParser::ParsedConfigVector* vector_ptr = nullptr;
   // 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 =
+  auto parsed_configs_or =
       CoreConfiguration::Get().service_config_parser().ParsePerMethodParameters(
-          args, json, &parser_error);
-  if (parser_error != GRPC_ERROR_NONE) {
-    error_list.push_back(parser_error);
+          args, json);
+  if (!parsed_configs_or.ok()) {
+    errors.emplace_back(parsed_configs_or.status().message());
+  } else {
+    auto parsed_configs =
+        absl::make_unique<ServiceConfigParser::ParsedConfigVector>(
+            std::move(*parsed_configs_or));
+    parsed_method_config_vectors_storage_.push_back(std::move(parsed_configs));
+    vector_ptr = parsed_method_config_vectors_storage_.back().get();
   }
-  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;
-        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;
+      errors.emplace_back("field:name error:not of type Array");
+    } else {
+      const Json::Array& name_array = it->second.array_value();
+      for (const Json& name : name_array) {
+        absl::StatusOr<std::string> path = ParseJsonMethodName(name);
+        if (!path.ok()) {
+          errors.emplace_back(path.status().message());
         } 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);
+          if (path->empty()) {
+            if (default_method_config_vector_ != nullptr) {
+              errors.emplace_back(
+                  "field:name error:multiple default method configs");
+            }
+            default_method_config_vector_ = vector_ptr;
           } else {
-            value = vector_ptr;
+            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];
+            if (value != nullptr) {
+              errors.emplace_back(
+                  "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 (!found_name) {
-    parsed_method_config_vectors_storage_.pop_back();
+  if (!errors.empty()) {
+    return absl::InvalidArgumentError(
+        absl::StrCat("index ", index, ": [", absl::StrJoin(errors, "; "), "]"));
   }
-  return GRPC_ERROR_CREATE_FROM_VECTOR("methodConfig", &error_list);
+  return absl::OkStatus();
 }
 
-grpc_error_handle ServiceConfigImpl::ParsePerMethodParams(
-    const grpc_channel_args* args) {
-  std::vector<grpc_error_handle> error_list;
+absl::Status ServiceConfigImpl::ParsePerMethodParams(const ChannelArgs& args) {
   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);
-      }
+  if (it == json_.object_value().end()) return absl::OkStatus();
+  if (it->second.type() != Json::Type::ARRAY) {
+    return absl::InvalidArgumentError("field must be of type array");
+  }
+  std::vector<std::string> errors;
+  for (size_t i = 0; i < it->second.array_value().size(); ++i) {
+    const Json& method_config = it->second.array_value()[i];
+    if (method_config.type() != Json::Type::OBJECT) {
+      errors.emplace_back(absl::StrCat("index ", i, ": not of type Object"));
+    } else {
+      absl::Status status = ParseJsonMethodConfig(args, method_config, i);
+      if (!status.ok()) errors.emplace_back(status.message());
     }
   }
-  return GRPC_ERROR_CREATE_FROM_VECTOR("Method Params", &error_list);
+  if (!errors.empty()) {
+    return absl::InvalidArgumentError(absl::StrCat(
+        "errors parsing methodConfig: [", absl::StrJoin(errors, "; "), "]"));
+  }
+  return absl::OkStatus();
 }
 
-std::string ServiceConfigImpl::ParseJsonMethodName(const Json& json,
-                                                   grpc_error_handle* error) {
+absl::StatusOr<std::string> ServiceConfigImpl::ParseJsonMethodName(
+    const Json& json) {
   if (json.type() != Json::Type::OBJECT) {
-    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:name error:type is not object");
-    return "";
+    return absl::InvalidArgumentError("field:name error:type is not object");
   }
   // Find service name.
   const std::string* service_name = nullptr;
@@ -177,9 +180,8 @@ std::string ServiceConfigImpl::ParseJsonMethodName(const Json& json,
   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(
+      return absl::InvalidArgumentError(
           "field:name error: field:service error:not of type string");
-      return "";
     }
     if (!it->second.string_value().empty()) {
       service_name = &it->second.string_value();
@@ -191,9 +193,8 @@ std::string ServiceConfigImpl::ParseJsonMethodName(const Json& json,
   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(
+      return absl::InvalidArgumentError(
           "field:name error: field:method error:not of type string");
-      return "";
     }
     if (!it->second.string_value().empty()) {
       method_name = &it->second.string_value();
@@ -203,7 +204,7 @@ std::string ServiceConfigImpl::ParseJsonMethodName(const Json& json,
   // Method name may not be specified without service name.
   if (service_name == nullptr) {
     if (method_name != nullptr) {
-      *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+      return absl::InvalidArgumentError(
           "field:name error:method name populated without service name");
     }
     return "";

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

@@ -26,15 +26,15 @@
 #include <unordered_map>
 #include <vector>
 
-#include "absl/container/inlined_vector.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/slice.h>
 #include <grpc/support/log.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/json/json.h"
 #include "src/core/lib/service_config/service_config.h"
 #include "src/core/lib/service_config/service_config_parser.h"
@@ -69,13 +69,11 @@ 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,
-                                             absl::string_view json_string,
-                                             grpc_error_handle* error);
+  static absl::StatusOr<RefCountedPtr<ServiceConfig>> Create(
+      const ChannelArgs& args, absl::string_view json_string);
 
-  ServiceConfigImpl(const grpc_channel_args* args, std::string json_string,
-                    Json json, grpc_error_handle* error);
+  ServiceConfigImpl(const ChannelArgs& args, std::string json_string, Json json,
+                    absl::Status* status);
   ~ServiceConfigImpl() override;
 
   absl::string_view json_string() const override { return json_string_; }
@@ -97,14 +95,13 @@ class ServiceConfigImpl final : public ServiceConfig {
 
  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);
+  absl::Status ParsePerMethodParams(const ChannelArgs& args);
+  absl::Status ParseJsonMethodConfig(const ChannelArgs& args, const Json& json,
+                                     size_t index);
 
   // 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);
+  static absl::StatusOr<std::string> ParseJsonMethodName(const Json& json);
 
   std::string json_string_;
   Json json_;
@@ -122,8 +119,7 @@ class ServiceConfigImpl final : public ServiceConfig {
       nullptr;
   // Storage for all the vectors that are being used in
   // parsed_method_configs_table_.
-  absl::InlinedVector<std::unique_ptr<ServiceConfigParser::ParsedConfigVector>,
-                      32>
+  std::vector<std::unique_ptr<ServiceConfigParser::ParsedConfigVector>>
       parsed_method_config_vectors_storage_;
 };
 

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

@@ -22,12 +22,12 @@
 
 #include <string>
 
+#include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
 
 #include <grpc/support/log.h>
 
-// IWYU pragma: no_include <ext/alloc_traits.h>
-
 namespace grpc_core {
 
 ServiceConfigParser ServiceConfigParser::Builder::Build() {
@@ -49,46 +49,43 @@ void ServiceConfigParser::Builder::RegisterParser(
   registered_parsers_.emplace_back(std::move(parser));
 }
 
-ServiceConfigParser::ParsedConfigVector
-ServiceConfigParser::ParseGlobalParameters(const grpc_channel_args* args,
-                                           const Json& json,
-                                           grpc_error_handle* error) const {
+absl::StatusOr<ServiceConfigParser::ParsedConfigVector>
+ServiceConfigParser::ParseGlobalParameters(const ChannelArgs& args,
+                                           const Json& json) const {
   ParsedConfigVector parsed_global_configs;
-  std::vector<grpc_error_handle> error_list;
+  std::vector<std::string> errors;
   for (size_t i = 0; i < registered_parsers_.size(); i++) {
-    grpc_error_handle parser_error = GRPC_ERROR_NONE;
-    auto parsed_config =
-        registered_parsers_[i]->ParseGlobalParams(args, json, &parser_error);
-    if (parser_error != GRPC_ERROR_NONE) {
-      error_list.push_back(parser_error);
+    auto parsed_config = registered_parsers_[i]->ParseGlobalParams(args, json);
+    if (!parsed_config.ok()) {
+      errors.emplace_back(parsed_config.status().message());
+    } else {
+      parsed_global_configs.push_back(std::move(*parsed_config));
     }
-    parsed_global_configs.push_back(std::move(parsed_config));
   }
-  if (!error_list.empty()) {
-    *error = GRPC_ERROR_CREATE_FROM_VECTOR("Global Params", &error_list);
+  if (!errors.empty()) {
+    return absl::InvalidArgumentError(absl::StrJoin(errors, "; "));
   }
-  return parsed_global_configs;
+  return std::move(parsed_global_configs);
 }
 
-ServiceConfigParser::ParsedConfigVector
-ServiceConfigParser::ParsePerMethodParameters(const grpc_channel_args* args,
-                                              const Json& json,
-                                              grpc_error_handle* error) const {
+absl::StatusOr<ServiceConfigParser::ParsedConfigVector>
+ServiceConfigParser::ParsePerMethodParameters(const ChannelArgs& args,
+                                              const Json& json) const {
   ParsedConfigVector parsed_method_configs;
-  std::vector<grpc_error_handle> error_list;
+  std::vector<std::string> errors;
   for (size_t i = 0; i < registered_parsers_.size(); ++i) {
-    grpc_error_handle parser_error = GRPC_ERROR_NONE;
     auto parsed_config =
-        registered_parsers_[i]->ParsePerMethodParams(args, json, &parser_error);
-    if (parser_error != GRPC_ERROR_NONE) {
-      error_list.push_back(parser_error);
+        registered_parsers_[i]->ParsePerMethodParams(args, json);
+    if (!parsed_config.ok()) {
+      errors.emplace_back(parsed_config.status().message());
+    } else {
+      parsed_method_configs.push_back(std::move(*parsed_config));
     }
-    parsed_method_configs.push_back(std::move(parsed_config));
   }
-  if (!error_list.empty()) {
-    *error = GRPC_ERROR_CREATE_FROM_VECTOR("methodConfig", &error_list);
+  if (!errors.empty()) {
+    return absl::InvalidArgumentError(absl::StrJoin(errors, "; "));
   }
-  return parsed_method_configs;
+  return std::move(parsed_method_configs);
 }
 
 size_t ServiceConfigParser::GetParserIndex(absl::string_view name) const {

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

@@ -26,12 +26,10 @@
 #include <utility>
 #include <vector>
 
+#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
-#include <grpc/support/log.h>
-
-#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/json/json.h"
 
 namespace grpc_core {
@@ -54,21 +52,13 @@ class ServiceConfigParser {
 
     virtual absl::string_view name() const = 0;
 
-    virtual std::unique_ptr<ParsedConfig> ParseGlobalParams(
-        const grpc_channel_args*, const Json& /* json */,
-        grpc_error_handle* error) {
-      // Avoid unused parameter warning on debug-only parameter
-      (void)error;
-      GPR_DEBUG_ASSERT(error != nullptr);
+    virtual absl::StatusOr<std::unique_ptr<ParsedConfig>> ParseGlobalParams(
+        const ChannelArgs& /*args*/, const Json& /*json*/) {
       return nullptr;
     }
 
-    virtual std::unique_ptr<ParsedConfig> ParsePerMethodParams(
-        const grpc_channel_args*, const Json& /* json */,
-        grpc_error_handle* error) {
-      // Avoid unused parameter warning on debug-only parameter
-      (void)error;
-      GPR_DEBUG_ASSERT(error != nullptr);
+    virtual absl::StatusOr<std::unique_ptr<ParsedConfig>> ParsePerMethodParams(
+        const ChannelArgs& /*args*/, const Json& /*json*/) {
       return nullptr;
     }
   };
@@ -90,13 +80,11 @@ class ServiceConfigParser {
     ServiceConfigParserList registered_parsers_;
   };
 
-  ParsedConfigVector ParseGlobalParameters(const grpc_channel_args* args,
-                                           const Json& json,
-                                           grpc_error_handle* error) const;
+  absl::StatusOr<ParsedConfigVector> ParseGlobalParameters(
+      const ChannelArgs& args, const Json& json) const;
 
-  ParsedConfigVector ParsePerMethodParameters(const grpc_channel_args* args,
-                                              const Json& json,
-                                              grpc_error_handle* error) const;
+  absl::StatusOr<ParsedConfigVector> ParsePerMethodParameters(
+      const ChannelArgs& args, const Json& json) const;
 
   // Return the index for a given registered parser.
   // If there is an error, return -1.