grpc 1.48.0 → 1.49.1

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

@@ -24,12 +24,11 @@
 #include <stdint.h>
 #include <string.h>
 
-#include <limits>
+#include <algorithm>
 #include <memory>
 #include <string>
 
 #include "absl/base/attributes.h"
-#include "absl/container/inlined_vector.h"
 #include "absl/memory/memory.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
@@ -75,7 +74,7 @@ class SecurityHandshaker : public Handshaker {
  public:
   SecurityHandshaker(tsi_handshaker* handshaker,
                      grpc_security_connector* connector,
-                     const grpc_channel_args* args);
+                     const ChannelArgs& args);
   ~SecurityHandshaker() override;
   void Shutdown(grpc_error_handle why) override;
   void DoHandshake(grpc_tcp_server_acceptor* acceptor,
@@ -132,19 +131,19 @@ class SecurityHandshaker : public Handshaker {
   RefCountedPtr<grpc_auth_context> auth_context_;
   tsi_handshaker_result* handshaker_result_ = nullptr;
   size_t max_frame_size_ = 0;
+  std::string tsi_handshake_error_;
 };
 
 SecurityHandshaker::SecurityHandshaker(tsi_handshaker* handshaker,
                                        grpc_security_connector* connector,
-                                       const grpc_channel_args* args)
+                                       const ChannelArgs& args)
     : handshaker_(handshaker),
       connector_(connector->Ref(DEBUG_LOCATION, "handshake")),
       handshake_buffer_size_(GRPC_INITIAL_HANDSHAKE_BUFFER_SIZE),
       handshake_buffer_(
           static_cast<uint8_t*>(gpr_malloc(handshake_buffer_size_))),
-      max_frame_size_(grpc_channel_args_find_integer(
-          args, GRPC_ARG_TSI_MAX_FRAME_SIZE,
-          {0, 0, std::numeric_limits<int>::max()})) {
+      max_frame_size_(
+          std::max(0, args.GetInt(GRPC_ARG_TSI_MAX_FRAME_SIZE).value_or(0))) {
   grpc_slice_buffer_init(&outgoing_);
   GRPC_CLOSURE_INIT(&on_peer_checked_, &SecurityHandshaker::OnPeerCheckedFn,
                     this, grpc_schedule_on_exec_ctx);
@@ -191,8 +190,7 @@ void SecurityHandshaker::CleanupArgsForFailureLocked() {
   args_->endpoint = nullptr;
   read_buffer_to_destroy_ = args_->read_buffer;
   args_->read_buffer = nullptr;
-  grpc_channel_args_destroy(args_->args);
-  args_->args = nullptr;
+  args_->args = ChannelArgs();
 }
 
 // If the handshake failed or we're shutting down, clean up and invoke the
@@ -319,14 +317,14 @@ void SecurityHandshaker::OnPeerCheckedInner(grpc_error_handle error) {
     if (unused_bytes_size > 0) {
       grpc_slice slice = grpc_slice_from_copied_buffer(
           reinterpret_cast<const char*>(unused_bytes), unused_bytes_size);
-      args_->endpoint =
-          grpc_secure_endpoint_create(protector, zero_copy_protector,
-                                      args_->endpoint, &slice, args_->args, 1);
+      args_->endpoint = grpc_secure_endpoint_create(
+          protector, zero_copy_protector, args_->endpoint, &slice,
+          args_->args.ToC().get(), 1);
       grpc_slice_unref_internal(slice);
     } else {
-      args_->endpoint =
-          grpc_secure_endpoint_create(protector, zero_copy_protector,
-                                      args_->endpoint, nullptr, args_->args, 0);
+      args_->endpoint = grpc_secure_endpoint_create(
+          protector, zero_copy_protector, args_->endpoint, nullptr,
+          args_->args.ToC().get(), 0);
     }
   } else if (unused_bytes_size > 0) {
     // Not wrapping the endpoint, so just pass along unused bytes.
@@ -337,21 +335,12 @@ void SecurityHandshaker::OnPeerCheckedInner(grpc_error_handle error) {
   // Done with handshaker result.
   tsi_handshaker_result_destroy(handshaker_result_);
   handshaker_result_ = nullptr;
-  absl::InlinedVector<grpc_arg, 2> args_to_add = {
-      // Add auth context to channel args.
-      grpc_auth_context_to_arg(auth_context_.get()),
-  };
-  RefCountedPtr<channelz::SocketNode::Security> channelz_security;
+  args_->args = args_->args.SetObject(auth_context_);
   // Add channelz channel args only if frame protector is created.
   if (has_frame_protector) {
-    channelz_security =
-        MakeChannelzSecurityFromAuthContext(auth_context_.get());
-    args_to_add.push_back(channelz_security->MakeChannelArg());
+    args_->args = args_->args.SetObject(
+        MakeChannelzSecurityFromAuthContext(auth_context_.get()));
   }
-  grpc_channel_args* tmp_args = args_->args;
-  args_->args = grpc_channel_args_copy_and_add(tmp_args, args_to_add.data(),
-                                               args_to_add.size());
-  grpc_channel_args_destroy(tmp_args);
   // Invoke callback.
   ExecCtx::Run(DEBUG_LOCATION, on_handshake_done_, GRPC_ERROR_NONE);
   // Set shutdown to true so that subsequent calls to
@@ -372,7 +361,7 @@ grpc_error_handle SecurityHandshaker::CheckPeerLocked() {
     return grpc_set_tsi_error_result(
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Peer extraction failed"), result);
   }
-  connector_->check_peer(peer, args_->endpoint, &auth_context_,
+  connector_->check_peer(peer, args_->endpoint, args_->args, &auth_context_,
                          &on_peer_checked_);
   return GRPC_ERROR_NONE;
 }
@@ -398,15 +387,15 @@ grpc_error_handle SecurityHandshaker::OnHandshakeNextDoneLocked(
     return error;
   }
   if (result != TSI_OK) {
-    auto* security_connector =
-        grpc_security_connector_find_in_args(args_->args);
+    auto* security_connector = args_->args.GetObject<grpc_security_connector>();
     absl::string_view connector_type = "<unknown>";
     if (security_connector != nullptr) {
       connector_type = security_connector->type().name();
     }
     return grpc_set_tsi_error_result(
-        GRPC_ERROR_CREATE_FROM_CPP_STRING(
-            absl::StrCat(connector_type, " handshake failed")),
+        GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+            connector_type, " handshake failed",
+            (tsi_handshake_error_.empty() ? "" : ": "), tsi_handshake_error_)),
         result);
   }
   // Update handshaker result.
@@ -466,7 +455,8 @@ grpc_error_handle SecurityHandshaker::DoHandshakerNextLocked(
   tsi_handshaker_result* hs_result = nullptr;
   tsi_result result = tsi_handshaker_next(
       handshaker_, bytes_received, bytes_received_size, &bytes_to_send,
-      &bytes_to_send_size, &hs_result, &OnHandshakeNextDoneGrpcWrapper, this);
+      &bytes_to_send_size, &hs_result, &OnHandshakeNextDoneGrpcWrapper, this,
+      &tsi_handshake_error_);
   if (result == TSI_ASYNC) {
     // Handshaker operating asynchronously. Nothing else to do here;
     // callback will be invoked in a TSI thread.
@@ -601,8 +591,7 @@ class FailHandshaker : public Handshaker {
     grpc_endpoint_shutdown(args->endpoint, GRPC_ERROR_REF(error));
     grpc_endpoint_destroy(args->endpoint);
     args->endpoint = nullptr;
-    grpc_channel_args_destroy(args->args);
-    args->args = nullptr;
+    args->args = ChannelArgs();
     grpc_slice_buffer_destroy_internal(args->read_buffer);
     gpr_free(args->read_buffer);
     args->read_buffer = nullptr;
@@ -619,12 +608,11 @@ class FailHandshaker : public Handshaker {
 
 class ClientSecurityHandshakerFactory : public HandshakerFactory {
  public:
-  void AddHandshakers(const grpc_channel_args* args,
+  void AddHandshakers(const ChannelArgs& args,
                       grpc_pollset_set* interested_parties,
                       HandshakeManager* handshake_mgr) override {
     auto* security_connector =
-        reinterpret_cast<grpc_channel_security_connector*>(
-            grpc_security_connector_find_in_args(args));
+        args.GetObject<grpc_channel_security_connector>();
     if (security_connector) {
       security_connector->add_handshakers(args, interested_parties,
                                           handshake_mgr);
@@ -635,12 +623,10 @@ class ClientSecurityHandshakerFactory : public HandshakerFactory {
 
 class ServerSecurityHandshakerFactory : public HandshakerFactory {
  public:
-  void AddHandshakers(const grpc_channel_args* args,
+  void AddHandshakers(const ChannelArgs& args,
                       grpc_pollset_set* interested_parties,
                       HandshakeManager* handshake_mgr) override {
-    auto* security_connector =
-        reinterpret_cast<grpc_server_security_connector*>(
-            grpc_security_connector_find_in_args(args));
+    auto* security_connector = args.GetObject<grpc_server_security_connector>();
     if (security_connector) {
       security_connector->add_handshakers(args, interested_parties,
                                           handshake_mgr);
@@ -657,7 +643,7 @@ class ServerSecurityHandshakerFactory : public HandshakerFactory {
 
 RefCountedPtr<Handshaker> SecurityHandshakerCreate(
     tsi_handshaker* handshaker, grpc_security_connector* connector,
-    const grpc_channel_args* args) {
+    const ChannelArgs& args) {
   // If no TSI handshaker was created, return a handshaker that always fails.
   // Otherwise, return a real security handshaker.
   if (handshaker == nullptr) {
@@ -681,5 +667,7 @@ void SecurityRegisterHandshakerFactories(CoreConfiguration::Builder* builder) {
 grpc_handshaker* grpc_security_handshaker_create(
     tsi_handshaker* handshaker, grpc_security_connector* connector,
     const grpc_channel_args* args) {
-  return SecurityHandshakerCreate(handshaker, connector, args).release();
+  return SecurityHandshakerCreate(handshaker, connector,
+                                  grpc_core::ChannelArgs::FromC(args))
+      .release();
 }

data/src/core/lib/security/transport/security_handshaker.h

@@ -23,6 +23,7 @@
 
 #include <grpc/impl/codegen/grpc_types.h>
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/security/security_connector/security_connector.h"
@@ -34,7 +35,7 @@ namespace grpc_core {
 /// Creates a security handshaker using \a handshaker.
 RefCountedPtr<Handshaker> SecurityHandshakerCreate(
     tsi_handshaker* handshaker, grpc_security_connector* connector,
-    const grpc_channel_args* args);
+    const ChannelArgs& args);
 
 /// Registers security handshaker factories.
 void SecurityRegisterHandshakerFactories(CoreConfiguration::Builder*);

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_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 (!GRPC_ERROR_IS_NONE(*error)) 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 (!GRPC_ERROR_IS_NONE(global_error)) error_list.push_back(global_error);
-  grpc_error_handle local_error = ParsePerMethodParams(args);
-  if (!GRPC_ERROR_IS_NONE(local_error)) 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 (!GRPC_ERROR_IS_NONE(parser_error)) {
-    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 (!GRPC_ERROR_IS_NONE(parse_error)) {
-        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 (!GRPC_ERROR_IS_NONE(error)) {
-        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,14 +26,15 @@
 #include <unordered_map>
 #include <vector>
 
+#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"
@@ -68,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_; }
@@ -96,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_;

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

@@ -22,7 +22,9 @@
 
 #include <string>
 
+#include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
 
 #include <grpc/support/log.h>
 
@@ -47,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 (!GRPC_ERROR_IS_NONE(parser_error)) {
-      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 (!GRPC_ERROR_IS_NONE(parser_error)) {
-      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 {