grpc 1.49.1-x86_64-linux → 1.50.0.pre1-x86_64-linux

data/src/core/lib/iomgr/tcp_server_windows.cc

@@ -29,6 +29,7 @@
 
 #include "absl/strings/str_cat.h"
 
+#include <grpc/event_engine/endpoint_config.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/log_windows.h>
@@ -37,7 +38,6 @@
 #include <grpc/support/time.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/pollset_windows.h"
 #include "src/core/lib/iomgr/resolve_address.h"
@@ -45,10 +45,13 @@
 #include "src/core/lib/iomgr/socket_windows.h"
 #include "src/core/lib/iomgr/tcp_server.h"
 #include "src/core/lib/iomgr/tcp_windows.h"
+#include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/slice/slice_internal.h"
 
 #define MIN_SAFE_ACCEPT_QUEUE_SIZE 100
 
+using ::grpc_event_engine::experimental::EndpointConfig;
+
 /* one listening port */
 typedef struct grpc_tcp_listener grpc_tcp_listener;
 struct grpc_tcp_listener {
@@ -94,17 +97,14 @@ struct grpc_tcp_server {
 
   /* shutdown callback */
   grpc_closure* shutdown_complete;
-
-  grpc_channel_args* channel_args;
 };
 
 /* Public function. Allocates the proper data structures to hold a
    grpc_tcp_server. */
 static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
-                                           const grpc_channel_args* args,
+                                           const EndpointConfig& config,
                                            grpc_tcp_server** server) {
   grpc_tcp_server* s = (grpc_tcp_server*)gpr_malloc(sizeof(grpc_tcp_server));
-  s->channel_args = grpc_channel_args_copy(args);
   gpr_ref_init(&s->refs, 1);
   gpr_mu_init(&s->mu);
   s->active_ports = 0;
@@ -132,7 +132,6 @@ static void destroy_server(void* arg, grpc_error_handle error) {
     grpc_winsocket_destroy(sp->socket);
     gpr_free(sp);
   }
-  grpc_channel_args_destroy(s->channel_args);
   gpr_mu_destroy(&s->mu);
   gpr_free(s);
 }
@@ -363,7 +362,7 @@ static void on_accept(void* arg, grpc_error_handle error) {
       }
       std::string fd_name = absl::StrCat("tcp_server:", peer_name_string);
       ep = grpc_tcp_create(grpc_winsocket_create(sock, fd_name.c_str()),
-                           sp->server->channel_args, peer_name_string);
+                           peer_name_string);
     } else {
       closesocket(sock);
     }

data/src/core/lib/iomgr/tcp_windows.cc

@@ -505,7 +505,6 @@ static grpc_endpoint_vtable vtable = {win_read,
                                       win_can_track_err};
 
 grpc_endpoint* grpc_tcp_create(grpc_winsocket* socket,
-                               grpc_channel_args* channel_args,
                                absl::string_view peer_string) {
   // TODO(jtattermusch): C++ize grpc_tcp and its dependencies (i.e. add
   // constructors) to ensure proper initialization

data/src/core/lib/iomgr/tcp_windows.h

@@ -41,7 +41,6 @@
  * Takes ownership of the handle.
  */
 grpc_endpoint* grpc_tcp_create(grpc_winsocket* socket,
-                               grpc_channel_args* channel_args,
                                absl::string_view peer_string);
 
 grpc_error_handle grpc_tcp_prepare_socket(SOCKET sock);

data/src/core/lib/iomgr/timer_generic.cc

@@ -253,7 +253,7 @@ static void timer_list_init() {
   g_shared_mutables.initialized = true;
   g_shared_mutables.checker_mu = GPR_SPINLOCK_INITIALIZER;
   gpr_mu_init(&g_shared_mutables.mu);
-  g_shared_mutables.min_timer = grpc_core::ExecCtx::Get()->Now();
+  g_shared_mutables.min_timer = grpc_core::Timestamp::Now();
 
   g_last_seen_min_timer = 0;
 
@@ -343,7 +343,7 @@ static void timer_init(grpc_timer* timer, grpc_core::Timestamp deadline,
   if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_trace)) {
     gpr_log(GPR_INFO, "TIMER %p: SET %" PRId64 " now %" PRId64 " call %p[%p]",
             timer, deadline.milliseconds_after_process_epoch(),
-            grpc_core::ExecCtx::Get()->Now().milliseconds_after_process_epoch(),
+            grpc_core::Timestamp::Now().milliseconds_after_process_epoch(),
             closure, closure->cb);
   }
 
@@ -358,7 +358,7 @@ static void timer_init(grpc_timer* timer, grpc_core::Timestamp deadline,
 
   gpr_mu_lock(&shard->mu);
   timer->pending = true;
-  grpc_core::Timestamp now = grpc_core::ExecCtx::Get()->Now();
+  grpc_core::Timestamp now = grpc_core::Timestamp::Now();
   if (deadline <= now) {
     timer->pending = false;
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, timer->closure, GRPC_ERROR_NONE);
@@ -665,7 +665,7 @@ static grpc_timer_check_result run_some_expired_timers(
 
 static grpc_timer_check_result timer_check(grpc_core::Timestamp* next) {
   // prelude
-  grpc_core::Timestamp now = grpc_core::ExecCtx::Get()->Now();
+  grpc_core::Timestamp now = grpc_core::Timestamp::Now();
 
   /* fetch from a thread-local first: this avoids contention on a globally
      mutable cacheline in the common case */

data/src/core/lib/iomgr/timer_manager.cc

@@ -184,8 +184,7 @@ static bool wait_until(grpc_core::Timestamp next) {
         g_timed_waiter_deadline = next;
 
         if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-          grpc_core::Duration wait_time =
-              next - grpc_core::ExecCtx::Get()->Now();
+          grpc_core::Duration wait_time = next - grpc_core::Timestamp::Now();
           gpr_log(GPR_INFO, "sleep for a %" PRId64 " milliseconds",
                   wait_time.millis());
         }

data/src/core/lib/iomgr/wakeup_fd_eventfd.cc

@@ -29,7 +29,6 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
-#include "src/core/lib/profiling/timers.h"
 
 static grpc_error_handle eventfd_create(grpc_wakeup_fd* fd_info) {
   fd_info->read_fd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
@@ -53,7 +52,6 @@ static grpc_error_handle eventfd_consume(grpc_wakeup_fd* fd_info) {
 }
 
 static grpc_error_handle eventfd_wakeup(grpc_wakeup_fd* fd_info) {
-  GPR_TIMER_SCOPE("eventfd_wakeup", 0);
   int err;
   do {
     err = eventfd_write(fd_info->read_fd, 1);

data/src/core/lib/json/json_object_loader.cc

@@ -16,53 +16,17 @@
 
 #include "src/core/lib/json/json_object_loader.h"
 
-#include <algorithm>
 #include <utility>
 
-#include "absl/status/status.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
 #include "absl/strings/strip.h"
 
 namespace grpc_core {
-
-void ErrorList::PushField(absl::string_view ext) {
-  // Skip leading '.' for top-level field names.
-  if (fields_.empty()) absl::ConsumePrefix(&ext, ".");
-  fields_.emplace_back(std::string(ext));
-}
-
-void ErrorList::PopField() { fields_.pop_back(); }
-
-void ErrorList::AddError(absl::string_view error) {
-  field_errors_[absl::StrJoin(fields_, "")].emplace_back(error);
-}
-
-bool ErrorList::FieldHasErrors() const {
-  return field_errors_.find(absl::StrJoin(fields_, "")) != field_errors_.end();
-}
-
-absl::Status ErrorList::status() const {
-  if (field_errors_.empty()) return absl::OkStatus();
-  std::vector<std::string> errors;
-  for (const auto& p : field_errors_) {
-    if (p.second.size() > 1) {
-      errors.emplace_back(absl::StrCat("field:", p.first, " errors:[",
-                                       absl::StrJoin(p.second, "; "), "]"));
-    } else {
-      errors.emplace_back(
-          absl::StrCat("field:", p.first, " error:", p.second[0]));
-    }
-  }
-  return absl::InvalidArgumentError(absl::StrCat(
-      "errors validating JSON: [", absl::StrJoin(errors, "; "), "]"));
-}
-
 namespace json_detail {
 
 void LoadScalar::LoadInto(const Json& json, const JsonArgs& /*args*/, void* dst,
-                          ErrorList* errors) const {
+                          ValidationErrors* errors) const {
   // We accept either STRING or NUMBER for numeric values, as per
   // https://developers.google.com/protocol-buffers/docs/proto3#json.
   if (json.type() != Json::Type::STRING &&
@@ -77,14 +41,14 @@ void LoadScalar::LoadInto(const Json& json, const JsonArgs& /*args*/, void* dst,
 bool LoadString::IsNumber() const { return false; }
 
 void LoadString::LoadInto(const std::string& value, void* dst,
-                          ErrorList*) const {
+                          ValidationErrors*) const {
   *static_cast<std::string*>(dst) = value;
 }
 
 bool LoadDuration::IsNumber() const { return false; }
 
 void LoadDuration::LoadInto(const std::string& value, void* dst,
-                            ErrorList* errors) const {
+                            ValidationErrors* errors) const {
   absl::string_view buf(value);
   if (!absl::ConsumeSuffix(&buf, "s")) {
     errors->AddError("Not a duration (no s suffix)");
@@ -121,7 +85,7 @@ void LoadDuration::LoadInto(const std::string& value, void* dst,
 bool LoadNumber::IsNumber() const { return true; }
 
 void LoadBool::LoadInto(const Json& json, const JsonArgs&, void* dst,
-                        ErrorList* errors) const {
+                        ValidationErrors* errors) const {
   if (json.type() == Json::Type::JSON_TRUE) {
     *static_cast<bool*>(dst) = true;
   } else if (json.type() == Json::Type::JSON_FALSE) {
@@ -132,7 +96,8 @@ void LoadBool::LoadInto(const Json& json, const JsonArgs&, void* dst,
 }
 
 void LoadUnprocessedJsonObject::LoadInto(const Json& json, const JsonArgs&,
-                                         void* dst, ErrorList* errors) const {
+                                         void* dst,
+                                         ValidationErrors* errors) const {
   if (json.type() != Json::Type::OBJECT) {
     errors->AddError("is not an object");
     return;
@@ -141,7 +106,7 @@ void LoadUnprocessedJsonObject::LoadInto(const Json& json, const JsonArgs&,
 }
 
 void LoadVector::LoadInto(const Json& json, const JsonArgs& args, void* dst,
-                          ErrorList* errors) const {
+                          ValidationErrors* errors) const {
   if (json.type() != Json::Type::ARRAY) {
     errors->AddError("is not an array");
     return;
@@ -149,7 +114,7 @@ void LoadVector::LoadInto(const Json& json, const JsonArgs& args, void* dst,
   const auto& array = json.array_value();
   const LoaderInterface* element_loader = ElementLoader();
   for (size_t i = 0; i < array.size(); ++i) {
-    ScopedField field(errors, absl::StrCat("[", i, "]"));
+    ValidationErrors::ScopedField field(errors, absl::StrCat("[", i, "]"));
     void* element = EmplaceBack(dst);
     element_loader->LoadInto(array[i], args, element, errors);
   }
@@ -157,7 +122,7 @@ void LoadVector::LoadInto(const Json& json, const JsonArgs& args, void* dst,
 
 void AutoLoader<std::vector<bool>>::LoadInto(const Json& json,
                                              const JsonArgs& args, void* dst,
-                                             ErrorList* errors) const {
+                                             ValidationErrors* errors) const {
   if (json.type() != Json::Type::ARRAY) {
     errors->AddError("is not an array");
     return;
@@ -166,7 +131,7 @@ void AutoLoader<std::vector<bool>>::LoadInto(const Json& json,
   const LoaderInterface* element_loader = LoaderForType<bool>();
   std::vector<bool>* vec = static_cast<std::vector<bool>*>(dst);
   for (size_t i = 0; i < array.size(); ++i) {
-    ScopedField field(errors, absl::StrCat("[", i, "]"));
+    ValidationErrors::ScopedField field(errors, absl::StrCat("[", i, "]"));
     bool elem = false;
     element_loader->LoadInto(array[i], args, &elem, errors);
     vec->push_back(elem);
@@ -174,28 +139,31 @@ void AutoLoader<std::vector<bool>>::LoadInto(const Json& json,
 }
 
 void LoadMap::LoadInto(const Json& json, const JsonArgs& args, void* dst,
-                       ErrorList* errors) const {
+                       ValidationErrors* errors) const {
   if (json.type() != Json::Type::OBJECT) {
     errors->AddError("is not an object");
     return;
   }
   const LoaderInterface* element_loader = ElementLoader();
   for (const auto& pair : json.object_value()) {
-    ScopedField field(errors, absl::StrCat("[\"", pair.first, "\"]"));
+    ValidationErrors::ScopedField field(errors,
+                                        absl::StrCat("[\"", pair.first, "\"]"));
     void* element = Insert(pair.first, dst);
     element_loader->LoadInto(pair.second, args, element, errors);
   }
 }
 
 void LoadOptional::LoadInto(const Json& json, const JsonArgs& args, void* dst,
-                            ErrorList* errors) const {
+                            ValidationErrors* errors) const {
   if (json.type() == Json::Type::JSON_NULL) return;
   void* element = Emplace(dst);
+  size_t starting_error_size = errors->size();
   ElementLoader()->LoadInto(json, args, element, errors);
+  if (errors->size() > starting_error_size) Reset(dst);
 }
 
 bool LoadObject(const Json& json, const JsonArgs& args, const Element* elements,
-                size_t num_elements, void* dst, ErrorList* errors) {
+                size_t num_elements, void* dst, ValidationErrors* errors) {
   if (json.type() != Json::Type::OBJECT) {
     errors->AddError("is not an object");
     return false;
@@ -205,7 +173,8 @@ bool LoadObject(const Json& json, const JsonArgs& args, const Element* elements,
     if (element.enable_key != nullptr && !args.IsEnabled(element.enable_key)) {
       continue;
     }
-    ScopedField field(errors, absl::StrCat(".", element.name));
+    ValidationErrors::ScopedField field(errors,
+                                        absl::StrCat(".", element.name));
     const auto& it = json.object_value().find(element.name);
     if (it == json.object_value().end()) {
       if (element.optional) continue;
@@ -219,8 +188,8 @@ bool LoadObject(const Json& json, const JsonArgs& args, const Element* elements,
 }
 
 const Json* GetJsonObjectField(const Json::Object& json,
-                               absl::string_view field, ErrorList* errors,
-                               bool required) {
+                               absl::string_view field,
+                               ValidationErrors* errors, bool required) {
   auto it = json.find(std::string(field));
   if (it == json.end()) {
     if (required) errors->AddError("field not present");

data/src/core/lib/json/json_object_loader.h

@@ -24,7 +24,6 @@
 #include <vector>
 
 #include "absl/meta/type_traits.h"
-#include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
@@ -32,7 +31,9 @@
 #include "absl/types/optional.h"
 
 #include "src/core/lib/gprpp/no_destruct.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/json/json_args.h"
 
@@ -51,7 +52,7 @@
 //   struct Foo {
 //     int a;
 //     int b;
-//     static const JsonLoaderInterface* JsonLoader() {
+//     static const JsonLoaderInterface* JsonLoader(const JsonArgs& args) {
 //       // Note: Field names must be string constants; they are not copied.
 //       static const auto* loader = JsonObjectLoader<Foo>()
 //           .Field("a", &Foo::a)
@@ -60,63 +61,24 @@
 //       return loader;
 //     }
 //     // Optional; omit if no post-processing needed.
-//     void JsonPostLoad(const Json& source, ErrorList* errors) { ++a; }
+//     void JsonPostLoad(const Json& source, const JsonArgs& args,
+//                       ValidationErrors* errors) {
+//       ++a;
+//     }
 //   };
 // Now we can load Foo objects from JSON:
 //   absl::StatusOr<Foo> foo = LoadFromJson<Foo>(json);
 namespace grpc_core {
 
-// A list of errors that occurred during JSON parsing.
-// If a non-empty list occurs during parsing, the parsing failed.
-class ErrorList {
- public:
-  // Record that we're reading some field.
-  void PushField(absl::string_view ext) GPR_ATTRIBUTE_NOINLINE;
-  // Record that we've finished reading that field.
-  void PopField() GPR_ATTRIBUTE_NOINLINE;
-
-  // Record that we've encountered an error.
-  void AddError(absl::string_view error) GPR_ATTRIBUTE_NOINLINE;
-  // Returns true if the current field has errors.
-  bool FieldHasErrors() const GPR_ATTRIBUTE_NOINLINE;
-
-  // Returns the resulting status of parsing.
-  absl::Status status() const;
-
-  // Return true if there are no errors.
-  bool ok() const { return field_errors_.empty(); }
-
-  size_t size() const { return field_errors_.size(); }
-
- private:
-  // TODO(roth): If we don't actually have any fields for which we
-  // report more than one error, simplify this data structure.
-  std::map<std::string /*field_name*/, std::vector<std::string>> field_errors_;
-  std::vector<std::string> fields_;
-};
-
-// Note that we're reading a field, and remove it at the end of the scope.
-class ScopedField {
- public:
-  ScopedField(ErrorList* error_list, absl::string_view field_name)
-      : error_list_(error_list) {
-    error_list_->PushField(field_name);
-  }
-  ~ScopedField() { error_list_->PopField(); }
-
- private:
-  ErrorList* error_list_;
-};
-
 namespace json_detail {
 
 // An un-typed JSON loader.
 class LoaderInterface {
  public:
   // Convert json value to whatever type we're loading at dst.
-  // If errors occur, add them to error_list.
+  // If errors occur, add them to errors.
   virtual void LoadInto(const Json& json, const JsonArgs& args, void* dst,
-                        ErrorList* errors) const = 0;
+                        ValidationErrors* errors) const = 0;
 
  protected:
   ~LoaderInterface() = default;
@@ -126,7 +88,7 @@ class LoaderInterface {
 class LoadScalar : public LoaderInterface {
  public:
   void LoadInto(const Json& json, const JsonArgs& args, void* dst,
-                ErrorList* errors) const override;
+                ValidationErrors* errors) const override;
 
  protected:
   ~LoadScalar() = default;
@@ -138,7 +100,7 @@ class LoadScalar : public LoaderInterface {
   virtual bool IsNumber() const = 0;
 
   virtual void LoadInto(const std::string& json, void* dst,
-                        ErrorList* errors) const = 0;
+                        ValidationErrors* errors) const = 0;
 };
 
 // Load a string.
@@ -149,7 +111,7 @@ class LoadString : public LoadScalar {
  private:
   bool IsNumber() const override;
   void LoadInto(const std::string& value, void* dst,
-                ErrorList* errors) const override;
+                ValidationErrors* errors) const override;
 };
 
 // Load a Duration.
@@ -160,7 +122,7 @@ class LoadDuration : public LoadScalar {
  private:
   bool IsNumber() const override;
   void LoadInto(const std::string& value, void* dst,
-                ErrorList* errors) const override;
+                ValidationErrors* errors) const override;
 };
 
 // Load a number.
@@ -180,7 +142,7 @@ class TypedLoadSignedNumber : public LoadNumber {
 
  private:
   void LoadInto(const std::string& value, void* dst,
-                ErrorList* errors) const override {
+                ValidationErrors* errors) const override {
     if (!absl::SimpleAtoi(value, static_cast<T*>(dst))) {
       errors->AddError("failed to parse number");
     }
@@ -195,7 +157,7 @@ class TypedLoadUnsignedNumber : public LoadNumber {
 
  private:
   void LoadInto(const std::string& value, void* dst,
-                ErrorList* errors) const override {
+                ValidationErrors* errors) const override {
     if (!absl::SimpleAtoi(value, static_cast<T*>(dst))) {
       errors->AddError("failed to parse non-negative number");
     }
@@ -209,7 +171,7 @@ class LoadFloat : public LoadNumber {
 
  private:
   void LoadInto(const std::string& value, void* dst,
-                ErrorList* errors) const override {
+                ValidationErrors* errors) const override {
     if (!absl::SimpleAtof(value, static_cast<float*>(dst))) {
       errors->AddError("failed to parse floating-point number");
     }
@@ -223,7 +185,7 @@ class LoadDouble : public LoadNumber {
 
  private:
   void LoadInto(const std::string& value, void* dst,
-                ErrorList* errors) const override {
+                ValidationErrors* errors) const override {
     if (!absl::SimpleAtod(value, static_cast<double*>(dst))) {
       errors->AddError("failed to parse floating-point number");
     }
@@ -234,7 +196,7 @@ class LoadDouble : public LoadNumber {
 class LoadBool : public LoaderInterface {
  public:
   void LoadInto(const Json& json, const JsonArgs& /*args*/, void* dst,
-                ErrorList* errors) const override;
+                ValidationErrors* errors) const override;
 
  protected:
   ~LoadBool() = default;
@@ -244,7 +206,7 @@ class LoadBool : public LoaderInterface {
 class LoadUnprocessedJsonObject : public LoaderInterface {
  public:
   void LoadInto(const Json& json, const JsonArgs& /*args*/, void* dst,
-                ErrorList* errors) const override;
+                ValidationErrors* errors) const override;
 
  protected:
   ~LoadUnprocessedJsonObject() = default;
@@ -254,7 +216,7 @@ class LoadUnprocessedJsonObject : public LoaderInterface {
 class LoadVector : public LoaderInterface {
  public:
   void LoadInto(const Json& json, const JsonArgs& args, void* dst,
-                ErrorList* errors) const override;
+                ValidationErrors* errors) const override;
 
  protected:
   ~LoadVector() = default;
@@ -268,7 +230,7 @@ class LoadVector : public LoaderInterface {
 class LoadMap : public LoaderInterface {
  public:
   void LoadInto(const Json& json, const JsonArgs& args, void* dst,
-                ErrorList* errors) const override;
+                ValidationErrors* errors) const override;
 
  protected:
   ~LoadMap() = default;
@@ -282,13 +244,14 @@ class LoadMap : public LoaderInterface {
 class LoadOptional : public LoaderInterface {
  public:
   void LoadInto(const Json& json, const JsonArgs& args, void* dst,
-                ErrorList* errors) const override;
+                ValidationErrors* errors) const override;
 
  protected:
   ~LoadOptional() = default;
 
  private:
   virtual void* Emplace(void* dst) const = 0;
+  virtual void Reset(void* dst) const = 0;
   virtual const LoaderInterface* ElementLoader() const = 0;
 };
 
@@ -304,7 +267,7 @@ template <typename T>
 class AutoLoader final : public LoaderInterface {
  public:
   void LoadInto(const Json& json, const JsonArgs& args, void* dst,
-                ErrorList* errors) const override {
+                ValidationErrors* errors) const override {
     T::JsonLoader(args)->LoadInto(json, args, dst, errors);
   }
 
@@ -387,7 +350,7 @@ template <>
 class AutoLoader<std::vector<bool>> final : public LoaderInterface {
  public:
   void LoadInto(const Json& json, const JsonArgs& args, void* dst,
-                ErrorList* errors) const override;
+                ValidationErrors* errors) const override;
 
  private:
   ~AutoLoader() = default;
@@ -417,6 +380,9 @@ class AutoLoader<absl::optional<T>> final : public LoadOptional {
   void* Emplace(void* dst) const final {
     return &static_cast<absl::optional<T>*>(dst)->emplace();
   }
+  void Reset(void* dst) const final {
+    static_cast<absl::optional<T>*>(dst)->reset();
+  }
   const LoaderInterface* ElementLoader() const final {
     return LoaderForType<T>();
   }
@@ -485,7 +451,7 @@ class Vec<T, 0> {
 // the object from some parsed JSON.
 // Returns false if the JSON object was not of type Json::Type::OBJECT.
 bool LoadObject(const Json& json, const JsonArgs& args, const Element* elements,
-                size_t num_elements, void* dst, ErrorList* errors);
+                size_t num_elements, void* dst, ValidationErrors* errors);
 
 // Adaptor type - takes a compile time computed list of elements and
 // implements LoaderInterface by calling LoadObject.
@@ -496,7 +462,7 @@ class FinishedJsonObjectLoader final : public LoaderInterface {
       : elements_(elements) {}
 
   void LoadInto(const Json& json, const JsonArgs& args, void* dst,
-                ErrorList* errors) const override {
+                ValidationErrors* errors) const override {
     LoadObject(json, args, elements_.data(), elements_.size(), dst, errors);
   }
 
@@ -514,7 +480,7 @@ class FinishedJsonObjectLoader<T, kElemCount,
       : elements_(elements) {}
 
   void LoadInto(const Json& json, const JsonArgs& args, void* dst,
-                ErrorList* errors) const override {
+                ValidationErrors* errors) const override {
     // Call JsonPostLoad() only if json is a JSON object.
     if (LoadObject(json, args, elements_.data(), elements_.size(), dst,
                    errors)) {
@@ -570,8 +536,8 @@ class JsonObjectLoader final {
 };
 
 const Json* GetJsonObjectField(const Json::Object& json,
-                               absl::string_view field, ErrorList* errors,
-                               bool required);
+                               absl::string_view field,
+                               ValidationErrors* errors, bool required);
 
 }  // namespace json_detail
 
@@ -581,19 +547,32 @@ using JsonObjectLoader = json_detail::JsonObjectLoader<T>;
 using JsonLoaderInterface = json_detail::LoaderInterface;
 
 template <typename T>
-absl::StatusOr<T> LoadFromJson(const Json& json,
-                               const JsonArgs& args = JsonArgs()) {
-  ErrorList error_list;
+absl::StatusOr<T> LoadFromJson(
+    const Json& json, const JsonArgs& args = JsonArgs(),
+    absl::string_view error_prefix = "errors validating JSON") {
+  ValidationErrors errors;
   T result{};
-  json_detail::LoaderForType<T>()->LoadInto(json, args, &result, &error_list);
-  if (!error_list.ok()) return error_list.status();
+  json_detail::LoaderForType<T>()->LoadInto(json, args, &result, &errors);
+  if (!errors.ok()) return errors.status(error_prefix);
+  return std::move(result);
+}
+
+template <typename T>
+absl::StatusOr<RefCountedPtr<T>> LoadRefCountedFromJson(
+    const Json& json, const JsonArgs& args = JsonArgs(),
+    absl::string_view error_prefix = "errors validating JSON") {
+  ValidationErrors errors;
+  auto result = MakeRefCounted<T>();
+  json_detail::LoaderForType<T>()->LoadInto(json, args, result.get(), &errors);
+  if (!errors.ok()) return errors.status(error_prefix);
   return std::move(result);
 }
 
 template <typename T>
-T LoadFromJson(const Json& json, const JsonArgs& args, ErrorList* error_list) {
+T LoadFromJson(const Json& json, const JsonArgs& args,
+               ValidationErrors* errors) {
   T result{};
-  json_detail::LoaderForType<T>()->LoadInto(json, args, &result, error_list);
+  json_detail::LoaderForType<T>()->LoadInto(json, args, &result, errors);
   return result;
 }
 
@@ -601,8 +580,9 @@ template <typename T>
 absl::optional<T> LoadJsonObjectField(const Json::Object& json,
                                       const JsonArgs& args,
                                       absl::string_view field,
-                                      ErrorList* errors, bool required = true) {
-  ScopedField error_field(errors, absl::StrCat(".", field));
+                                      ValidationErrors* errors,
+                                      bool required = true) {
+  ValidationErrors::ScopedField error_field(errors, absl::StrCat(".", field));
   const Json* field_json =
       json_detail::GetJsonObjectField(json, field, errors, required);
   if (field_json == nullptr) return absl::nullopt;

data/src/core/lib/json/json_util.cc

@@ -21,13 +21,14 @@
 #include "src/core/lib/json/json_util.h"
 
 #include "src/core/lib/gprpp/no_destruct.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/json/json_args.h"
 #include "src/core/lib/json/json_object_loader.h"
 
 namespace grpc_core {
 
 bool ParseDurationFromJson(const Json& field, Duration* duration) {
-  ErrorList errors;
+  ValidationErrors errors;
   static_cast<json_detail::LoaderInterface*>(
       NoDestructSingleton<json_detail::AutoLoader<Duration>>::Get())
       ->LoadInto(field, JsonArgs(), duration, &errors);