grpc 1.54.0 → 1.55.0

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

@@ -77,6 +77,9 @@ PosixTcpOptions TcpOptionsFromEndpointConfig(const EndpointConfig& config) {
   options.tcp_tx_zerocopy_max_simultaneous_sends =
       AdjustValue(PosixTcpOptions::kDefaultMaxSends, 0, INT_MAX,
                   config.GetInt(GRPC_ARG_TCP_TX_ZEROCOPY_MAX_SIMULT_SENDS));
+  options.tcp_receive_buffer_size =
+      AdjustValue(PosixTcpOptions::kReadBufferSizeUnset, 0, INT_MAX,
+                  config.GetInt(GRPC_ARG_TCP_RECEIVE_BUFFER_SIZE));
   options.tcp_tx_zero_copy_enabled =
       (AdjustValue(PosixTcpOptions::kZerocpTxEnabledDefault, 0, 1,
                    config.GetInt(GRPC_ARG_TCP_TX_ZEROCOPY_ENABLED)) != 0);

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

@@ -49,11 +49,14 @@ struct PosixTcpOptions {
   static constexpr int kMaxChunkSize = 32 * 1024 * 1024;
   static constexpr int kDefaultMaxSends = 4;
   static constexpr size_t kDefaultSendBytesThreshold = 16 * 1024;
+  // Let the system decide the proper buffer size.
+  static constexpr int kReadBufferSizeUnset = -1;
   int tcp_read_chunk_size = kDefaultReadChunkSize;
   int tcp_min_read_chunk_size = kDefaultMinReadChunksize;
   int tcp_max_read_chunk_size = kDefaultMaxReadChunksize;
   int tcp_tx_zerocopy_send_bytes_threshold = kDefaultSendBytesThreshold;
   int tcp_tx_zerocopy_max_simultaneous_sends = kDefaultMaxSends;
+  int tcp_receive_buffer_size = kReadBufferSizeUnset;
   bool tcp_tx_zero_copy_enabled = kZerocpTxEnabledDefault;
   int keep_alive_time_ms = 0;
   int keep_alive_timeout_ms = 0;

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

@@ -107,6 +107,10 @@ static grpc_error_handle prepare_socket(
   if (!err.ok()) goto error;
   err = grpc_set_socket_cloexec(fd, 1);
   if (!err.ok()) goto error;
+  if (options.tcp_receive_buffer_size != options.kReadBufferSizeUnset) {
+    err = grpc_set_socket_rcvbuf(fd, options.tcp_receive_buffer_size);
+    if (!err.ok()) goto error;
+  }
   if (!grpc_is_unix_socket(addr)) {
     err = grpc_set_socket_low_latency(fd, 1);
     if (!err.ok()) goto error;

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

@@ -338,7 +338,7 @@ static void timer_init(grpc_timer* timer, grpc_core::Timestamp deadline,
 #endif
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_trace)) {
-    gpr_log(GPR_INFO, "TIMER %p: SET %" PRId64 " now %" PRId64 " call %p[%p]",
+    gpr_log(GPR_DEBUG, "TIMER %p: SET %" PRId64 " now %" PRId64 " call %p[%p]",
             timer, deadline.milliseconds_after_process_epoch(),
             grpc_core::Timestamp::Now().milliseconds_after_process_epoch(),
             closure, closure->cb);
@@ -374,7 +374,7 @@ static void timer_init(grpc_timer* timer, grpc_core::Timestamp deadline,
     list_join(&shard->list, timer);
   }
   if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_trace)) {
-    gpr_log(GPR_INFO,
+    gpr_log(GPR_DEBUG,
             "  .. add to shard %d with queue_deadline_cap=%" PRId64
             " => is_first_timer=%s",
             static_cast<int>(shard - g_shards),
@@ -397,7 +397,7 @@ static void timer_init(grpc_timer* timer, grpc_core::Timestamp deadline,
   if (is_first_timer) {
     gpr_mu_lock(&g_shared_mutables.mu);
     if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_trace)) {
-      gpr_log(GPR_INFO, "  .. old shard min_deadline=%" PRId64,
+      gpr_log(GPR_DEBUG, "  .. old shard min_deadline=%" PRId64,
               shard->min_deadline.milliseconds_after_process_epoch());
     }
     if (deadline < shard->min_deadline) {
@@ -439,7 +439,7 @@ static void timer_cancel(grpc_timer* timer) {
   timer_shard* shard = &g_shards[grpc_core::HashPointer(timer, g_num_shards)];
   gpr_mu_lock(&shard->mu);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_trace)) {
-    gpr_log(GPR_INFO, "TIMER %p: CANCEL pending=%s", timer,
+    gpr_log(GPR_DEBUG, "TIMER %p: CANCEL pending=%s", timer,
             timer->pending ? "true" : "false");
   }
 
@@ -480,7 +480,7 @@ static bool refill_heap(timer_shard* shard, grpc_core::Timestamp now) {
       grpc_core::Duration::FromSecondsAsDouble(deadline_delta);
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-    gpr_log(GPR_INFO, "  .. shard[%d]->queue_deadline_cap --> %" PRId64,
+    gpr_log(GPR_DEBUG, "  .. shard[%d]->queue_deadline_cap --> %" PRId64,
             static_cast<int>(shard - g_shards),
             shard->queue_deadline_cap.milliseconds_after_process_epoch());
   }
@@ -492,7 +492,7 @@ static bool refill_heap(timer_shard* shard, grpc_core::Timestamp now) {
 
     if (timer_deadline < shard->queue_deadline_cap) {
       if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-        gpr_log(GPR_INFO, "  .. add timer with deadline %" PRId64 " to heap",
+        gpr_log(GPR_DEBUG, "  .. add timer with deadline %" PRId64 " to heap",
                 timer_deadline.milliseconds_after_process_epoch());
       }
       list_remove(timer);
@@ -509,7 +509,7 @@ static grpc_timer* pop_one(timer_shard* shard, grpc_core::Timestamp now) {
   grpc_timer* timer;
   for (;;) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-      gpr_log(GPR_INFO, "  .. shard[%d]: heap_empty=%s",
+      gpr_log(GPR_DEBUG, "  .. shard[%d]: heap_empty=%s",
               static_cast<int>(shard - g_shards),
               grpc_timer_heap_is_empty(&shard->heap) ? "true" : "false");
     }
@@ -522,14 +522,14 @@ static grpc_timer* pop_one(timer_shard* shard, grpc_core::Timestamp now) {
         grpc_core::Timestamp::FromMillisecondsAfterProcessEpoch(
             timer->deadline);
     if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-      gpr_log(GPR_INFO,
+      gpr_log(GPR_DEBUG,
               "  .. check top timer deadline=%" PRId64 " now=%" PRId64,
               timer_deadline.milliseconds_after_process_epoch(),
               now.milliseconds_after_process_epoch());
     }
     if (timer_deadline > now) return nullptr;
     if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_trace)) {
-      gpr_log(GPR_INFO, "TIMER %p: FIRE %" PRId64 "ms late", timer,
+      gpr_log(GPR_DEBUG, "TIMER %p: FIRE %" PRId64 "ms late", timer,
               (now - timer_deadline).millis());
     }
     timer->pending = false;
@@ -553,7 +553,7 @@ static size_t pop_timers(timer_shard* shard, grpc_core::Timestamp now,
   *new_min_deadline = compute_min_deadline(shard);
   gpr_mu_unlock(&shard->mu);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-    gpr_log(GPR_INFO, "  .. shard[%d] popped %" PRIdPTR,
+    gpr_log(GPR_DEBUG, "  .. shard[%d] popped %" PRIdPTR,
             static_cast<int>(shard - g_shards), n);
   }
   return n;
@@ -593,7 +593,7 @@ static grpc_timer_check_result run_some_expired_timers(
 
     if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
       gpr_log(
-          GPR_INFO, "  .. shard[%d]->min_deadline = %" PRId64,
+          GPR_DEBUG, "  .. shard[%d]->min_deadline = %" PRId64,
           static_cast<int>(g_shard_queue[0] - g_shards),
           g_shard_queue[0]->min_deadline.milliseconds_after_process_epoch());
     }
@@ -612,7 +612,7 @@ static grpc_timer_check_result run_some_expired_timers(
 
       if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
         gpr_log(
-            GPR_INFO,
+            GPR_DEBUG,
             "  .. result --> %d"
             ", shard[%d]->min_deadline %" PRId64 " --> %" PRId64
             ", now=%" PRId64,
@@ -671,7 +671,7 @@ static grpc_timer_check_result timer_check(grpc_core::Timestamp* next) {
       *next = std::min(*next, min_timer);
     }
     if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-      gpr_log(GPR_INFO, "TIMER CHECK SKIP: now=%" PRId64 " min_timer=%" PRId64,
+      gpr_log(GPR_DEBUG, "TIMER CHECK SKIP: now=%" PRId64 " min_timer=%" PRId64,
               now.milliseconds_after_process_epoch(),
               min_timer.milliseconds_after_process_epoch());
     }
@@ -693,7 +693,7 @@ static grpc_timer_check_result timer_check(grpc_core::Timestamp* next) {
     }
 #if GPR_ARCH_64
     gpr_log(
-        GPR_INFO,
+        GPR_DEBUG,
         "TIMER CHECK BEGIN: now=%" PRId64 " next=%s tls_min=%" PRId64
         " glob_min=%" PRId64,
         now.milliseconds_after_process_epoch(), next_str.c_str(),
@@ -702,7 +702,8 @@ static grpc_timer_check_result timer_check(grpc_core::Timestamp* next) {
             gpr_atm_no_barrier_load((gpr_atm*)(&g_shared_mutables.min_timer)))
             .milliseconds_after_process_epoch());
 #else
-    gpr_log(GPR_INFO, "TIMER CHECK BEGIN: now=%" PRId64 " next=%s min=%" PRId64,
+    gpr_log(GPR_DEBUG,
+            "TIMER CHECK BEGIN: now=%" PRId64 " next=%s min=%" PRId64,
             now.milliseconds_after_process_epoch(), next_str.c_str(),
             min_timer.milliseconds_after_process_epoch());
 #endif
@@ -718,7 +719,7 @@ static grpc_timer_check_result timer_check(grpc_core::Timestamp* next) {
     } else {
       next_str = absl::StrCat(next->milliseconds_after_process_epoch());
     }
-    gpr_log(GPR_INFO, "TIMER CHECK END: r=%d; next=%s", r, next_str.c_str());
+    gpr_log(GPR_DEBUG, "TIMER CHECK END: r=%d; next=%s", r, next_str.c_str());
   }
   return r;
 }

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

@@ -24,8 +24,7 @@
 #include <utility>
 #include <vector>
 
-#include "absl/status/statusor.h"
-#include "absl/strings/string_view.h"
+#include "absl/types/variant.h"
 
 namespace grpc_core {
 
@@ -38,46 +37,34 @@ class Json {
   // consider whether there's a better alternative (e.g., maybe storing
   // each numeric type as the native C++ type and automatically converting
   // to string as needed).
-  enum class Type {
-    JSON_NULL,
-    JSON_TRUE,
-    JSON_FALSE,
-    NUMBER,
-    STRING,
-    OBJECT,
-    ARRAY
-  };
+  enum class Type { kNull, kTrue, kFalse, kNumber, kString, kObject, kArray };
 
   using Object = std::map<std::string, Json>;
   using Array = std::vector<Json>;
 
-  // Parses JSON string from json_str.
-  static absl::StatusOr<Json> Parse(absl::string_view json_str);
-
   Json() = default;
 
   // Copyable.
-  Json(const Json& other) { CopyFrom(other); }
-  Json& operator=(const Json& other) {
-    CopyFrom(other);
-    return *this;
-  }
+  Json(const Json& other) = default;
+  Json& operator=(const Json& other) = default;
 
   // Moveable.
-  Json(Json&& other) noexcept { MoveFrom(std::move(other)); }
+  Json(Json&& other) noexcept : value_(std::move(other.value_)) {
+    other.value_ = absl::monostate();
+  }
   Json& operator=(Json&& other) noexcept {
-    MoveFrom(std::move(other));
+    value_ = std::move(other.value_);
+    other.value_ = absl::monostate();
     return *this;
   }
 
   // Construct from copying a string.
-  // If is_number is true, the type will be NUMBER instead of STRING.
+  // If is_number is true, the type will be kNumber instead of kString.
   // NOLINTNEXTLINE(google-explicit-constructor)
   Json(const std::string& string, bool is_number = false)
-      : type_(is_number ? Type::NUMBER : Type::STRING), string_value_(string) {}
+      : value_(is_number ? Value(NumberValue{string}) : Value(string)) {}
   Json& operator=(const std::string& string) {
-    type_ = Type::STRING;
-    string_value_ = string;
+    value_ = string;
     return *this;
   }
 
@@ -99,146 +86,107 @@ class Json {
 
   // Construct by moving a string.
   // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(std::string&& string)
-      : type_(Type::STRING), string_value_(std::move(string)) {}
+  Json(std::string&& string) : value_(Value(std::move(string))) {}
   Json& operator=(std::string&& string) {
-    type_ = Type::STRING;
-    string_value_ = std::move(string);
+    value_ = Value(std::move(string));
     return *this;
   }
 
   // Construct from bool.
   // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(bool b) : type_(b ? Type::JSON_TRUE : Type::JSON_FALSE) {}
+  Json(bool b) : value_(b) {}
   Json& operator=(bool b) {
-    type_ = b ? Type::JSON_TRUE : Type::JSON_FALSE;
+    value_ = b;
     return *this;
   }
 
   // Construct from any numeric type.
   template <typename NumericType>
   // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(NumericType number)
-      : type_(Type::NUMBER), string_value_(std::to_string(number)) {}
+  Json(NumericType number) : value_(NumberValue{std::to_string(number)}) {}
   template <typename NumericType>
   Json& operator=(NumericType number) {
-    type_ = Type::NUMBER;
-    string_value_ = std::to_string(number);
+    value_ = NumberValue{std::to_string(number)};
     return *this;
   }
 
   // Construct by copying object.
   // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(const Object& object) : type_(Type::OBJECT), object_value_(object) {}
+  Json(const Object& object) : value_(object) {}
   Json& operator=(const Object& object) {
-    type_ = Type::OBJECT;
-    object_value_ = object;
+    value_ = object;
     return *this;
   }
 
   // Construct by moving object.
   // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(Object&& object)
-      : type_(Type::OBJECT), object_value_(std::move(object)) {}
+  Json(Object&& object) : value_(std::move(object)) {}
   Json& operator=(Object&& object) {
-    type_ = Type::OBJECT;
-    object_value_ = std::move(object);
+    value_ = std::move(object);
     return *this;
   }
 
   // Construct by copying array.
   // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(const Array& array) : type_(Type::ARRAY), array_value_(array) {}
+  Json(const Array& array) : value_(array) {}
   Json& operator=(const Array& array) {
-    type_ = Type::ARRAY;
-    array_value_ = array;
+    value_ = array;
     return *this;
   }
 
   // Construct by moving array.
   // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(Array&& array) : type_(Type::ARRAY), array_value_(std::move(array)) {}
+  Json(Array&& array) : value_(std::move(array)) {}
   Json& operator=(Array&& array) {
-    type_ = Type::ARRAY;
-    array_value_ = std::move(array);
+    value_ = std::move(array);
     return *this;
   }
 
-  // Dumps JSON from value to string form.
-  std::string Dump(int indent = 0) const;
+  // Returns the JSON type.
+  Type type() const {
+    struct ValueFunctor {
+      Json::Type operator()(const absl::monostate&) { return Type::kNull; }
+      Json::Type operator()(bool value) {
+        return value ? Type::kTrue : Type::kFalse;
+      }
+      Json::Type operator()(const NumberValue&) { return Type::kNumber; }
+      Json::Type operator()(const std::string&) { return Type::kString; }
+      Json::Type operator()(const Object&) { return Type::kObject; }
+      Json::Type operator()(const Array&) { return Type::kArray; }
+    };
+    return absl::visit(ValueFunctor(), value_);
+  }
 
   // Accessor methods.
-  Type type() const { return type_; }
-  const std::string& string_value() const { return string_value_; }
-  std::string* mutable_string_value() { return &string_value_; }
-  const Object& object_value() const { return object_value_; }
-  Object* mutable_object() { return &object_value_; }
-  const Array& array_value() const { return array_value_; }
-  Array* mutable_array() { return &array_value_; }
-
-  bool operator==(const Json& other) const {
-    if (type_ != other.type_) return false;
-    switch (type_) {
-      case Type::NUMBER:
-      case Type::STRING:
-        if (string_value_ != other.string_value_) return false;
-        break;
-      case Type::OBJECT:
-        if (object_value_ != other.object_value_) return false;
-        break;
-      case Type::ARRAY:
-        if (array_value_ != other.array_value_) return false;
-        break;
-      default:
-        break;
-    }
-    return true;
+  const std::string& string() const {
+    const NumberValue* num = absl::get_if<NumberValue>(&value_);
+    if (num != nullptr) return num->value;
+    return absl::get<std::string>(value_);
   }
+  const Object& object() const { return absl::get<Object>(value_); }
+  const Array& array() const { return absl::get<Array>(value_); }
 
+  bool operator==(const Json& other) const { return value_ == other.value_; }
   bool operator!=(const Json& other) const { return !(*this == other); }
 
  private:
-  void CopyFrom(const Json& other) {
-    type_ = other.type_;
-    switch (type_) {
-      case Type::NUMBER:
-      case Type::STRING:
-        string_value_ = other.string_value_;
-        break;
-      case Type::OBJECT:
-        object_value_ = other.object_value_;
-        break;
-      case Type::ARRAY:
-        array_value_ = other.array_value_;
-        break;
-      default:
-        break;
-    }
-  }
+  struct NumberValue {
+    std::string value;
 
-  void MoveFrom(Json&& other) {
-    type_ = other.type_;
-    other.type_ = Type::JSON_NULL;
-    switch (type_) {
-      case Type::NUMBER:
-      case Type::STRING:
-        string_value_ = std::move(other.string_value_);
-        break;
-      case Type::OBJECT:
-        object_value_ = std::move(other.object_value_);
-        break;
-      case Type::ARRAY:
-        array_value_ = std::move(other.array_value_);
-        break;
-      default:
-        break;
+    bool operator==(const NumberValue& other) const {
+      return value == other.value;
     }
-  }
+  };
+  using Value = absl::variant<absl::monostate,  // kNull
+                              bool,             // kTrue or kFalse
+                              NumberValue,      // kNumber
+                              std::string,      // kString
+                              Object,           // kObject
+                              Array>;           // kArray
+
+  explicit Json(Value value) : value_(std::move(value)) {}
 
-  Type type_ = Type::JSON_NULL;
-  std::string string_value_;
-  Object object_value_;
-  Array array_value_;
+  Value value_;
 };
 
 }  // namespace grpc_core

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

@@ -27,15 +27,15 @@ namespace json_detail {
 
 void LoadScalar::LoadInto(const Json& json, const JsonArgs& /*args*/, void* dst,
                           ValidationErrors* errors) const {
-  // We accept either STRING or NUMBER for numeric values, as per
+  // We accept either kString or kNumber for numeric values, as per
   // https://developers.google.com/protocol-buffers/docs/proto3#json.
-  if (json.type() != Json::Type::STRING &&
-      (!IsNumber() || json.type() != Json::Type::NUMBER)) {
+  if (json.type() != Json::Type::kString &&
+      (!IsNumber() || json.type() != Json::Type::kNumber)) {
     errors->AddError(
         absl::StrCat("is not a ", IsNumber() ? "number" : "string"));
     return;
   }
-  return LoadInto(json.string_value(), dst, errors);
+  return LoadInto(json.string(), dst, errors);
 }
 
 bool LoadString::IsNumber() const { return false; }
@@ -91,9 +91,9 @@ bool LoadNumber::IsNumber() const { return true; }
 
 void LoadBool::LoadInto(const Json& json, const JsonArgs&, void* dst,
                         ValidationErrors* errors) const {
-  if (json.type() == Json::Type::JSON_TRUE) {
+  if (json.type() == Json::Type::kTrue) {
     *static_cast<bool*>(dst) = true;
-  } else if (json.type() == Json::Type::JSON_FALSE) {
+  } else if (json.type() == Json::Type::kFalse) {
     *static_cast<bool*>(dst) = false;
   } else {
     errors->AddError("is not a boolean");
@@ -103,30 +103,30 @@ void LoadBool::LoadInto(const Json& json, const JsonArgs&, void* dst,
 void LoadUnprocessedJsonObject::LoadInto(const Json& json, const JsonArgs&,
                                          void* dst,
                                          ValidationErrors* errors) const {
-  if (json.type() != Json::Type::OBJECT) {
+  if (json.type() != Json::Type::kObject) {
     errors->AddError("is not an object");
     return;
   }
-  *static_cast<Json::Object*>(dst) = json.object_value();
+  *static_cast<Json::Object*>(dst) = json.object();
 }
 
 void LoadUnprocessedJsonArray::LoadInto(const Json& json, const JsonArgs&,
                                         void* dst,
                                         ValidationErrors* errors) const {
-  if (json.type() != Json::Type::ARRAY) {
+  if (json.type() != Json::Type::kArray) {
     errors->AddError("is not an array");
     return;
   }
-  *static_cast<Json::Array*>(dst) = json.array_value();
+  *static_cast<Json::Array*>(dst) = json.array();
 }
 
 void LoadVector::LoadInto(const Json& json, const JsonArgs& args, void* dst,
                           ValidationErrors* errors) const {
-  if (json.type() != Json::Type::ARRAY) {
+  if (json.type() != Json::Type::kArray) {
     errors->AddError("is not an array");
     return;
   }
-  const auto& array = json.array_value();
+  const auto& array = json.array();
   const LoaderInterface* element_loader = ElementLoader();
   for (size_t i = 0; i < array.size(); ++i) {
     ValidationErrors::ScopedField field(errors, absl::StrCat("[", i, "]"));
@@ -138,11 +138,11 @@ 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,
                                              ValidationErrors* errors) const {
-  if (json.type() != Json::Type::ARRAY) {
+  if (json.type() != Json::Type::kArray) {
     errors->AddError("is not an array");
     return;
   }
-  const auto& array = json.array_value();
+  const auto& array = json.array();
   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) {
@@ -155,12 +155,12 @@ void AutoLoader<std::vector<bool>>::LoadInto(const Json& json,
 
 void LoadMap::LoadInto(const Json& json, const JsonArgs& args, void* dst,
                        ValidationErrors* errors) const {
-  if (json.type() != Json::Type::OBJECT) {
+  if (json.type() != Json::Type::kObject) {
     errors->AddError("is not an object");
     return;
   }
   const LoaderInterface* element_loader = ElementLoader();
-  for (const auto& pair : json.object_value()) {
+  for (const auto& pair : json.object()) {
     ValidationErrors::ScopedField field(errors,
                                         absl::StrCat("[\"", pair.first, "\"]"));
     void* element = Insert(pair.first, dst);
@@ -170,7 +170,7 @@ void LoadMap::LoadInto(const Json& json, const JsonArgs& args, void* dst,
 
 void LoadOptional::LoadInto(const Json& json, const JsonArgs& args, void* dst,
                             ValidationErrors* errors) const {
-  if (json.type() == Json::Type::JSON_NULL) return;
+  if (json.type() == Json::Type::kNull) return;
   void* element = Emplace(dst);
   size_t starting_error_size = errors->size();
   ElementLoader()->LoadInto(json, args, element, errors);
@@ -179,7 +179,7 @@ void LoadOptional::LoadInto(const Json& json, const JsonArgs& args, void* dst,
 
 bool LoadObject(const Json& json, const JsonArgs& args, const Element* elements,
                 size_t num_elements, void* dst, ValidationErrors* errors) {
-  if (json.type() != Json::Type::OBJECT) {
+  if (json.type() != Json::Type::kObject) {
     errors->AddError("is not an object");
     return false;
   }
@@ -190,8 +190,8 @@ bool LoadObject(const Json& json, const JsonArgs& args, const Element* elements,
     }
     ValidationErrors::ScopedField field(errors,
                                         absl::StrCat(".", element.name));
-    const auto& it = json.object_value().find(element.name);
-    if (it == json.object_value().end()) {
+    const auto& it = json.object().find(element.name);
+    if (it == json.object().end()) {
       if (element.optional) continue;
       errors->AddError("field not present");
       continue;

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

@@ -26,6 +26,7 @@
 #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"
@@ -485,7 +486,7 @@ class Vec<T, 0> {
 
 // Given a list of elements, and a destination object, load the elements into
 // the object from some parsed JSON.
-// Returns false if the JSON object was not of type Json::Type::OBJECT.
+// Returns false if the JSON object was not of type Json::Type::kObject.
 bool LoadObject(const Json& json, const JsonArgs& args, const Element* elements,
                 size_t num_elements, void* dst, ValidationErrors* errors);
 
@@ -589,7 +590,9 @@ absl::StatusOr<T> LoadFromJson(
   ValidationErrors errors;
   T result{};
   json_detail::LoaderForType<T>()->LoadInto(json, args, &result, &errors);
-  if (!errors.ok()) return errors.status(error_prefix);
+  if (!errors.ok()) {
+    return errors.status(absl::StatusCode::kInvalidArgument, error_prefix);
+  }
   return std::move(result);
 }
 
@@ -600,7 +603,9 @@ absl::StatusOr<RefCountedPtr<T>> LoadRefCountedFromJson(
   ValidationErrors errors;
   auto result = MakeRefCounted<T>();
   json_detail::LoaderForType<T>()->LoadInto(json, args, result.get(), &errors);
-  if (!errors.ok()) return errors.status(error_prefix);
+  if (!errors.ok()) {
+    return errors.status(absl::StatusCode::kInvalidArgument, error_prefix);
+  }
   return std::move(result);
 }