grpc 1.54.3 → 1.55.0

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);
 }
 

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

@@ -33,9 +33,11 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/variant.h"
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/match.h"
 #include "src/core/lib/json/json.h"
 
 #define GRPC_JSON_MAX_DEPTH 255
@@ -93,6 +95,23 @@ class JsonReader {
   //
   static constexpr uint32_t GRPC_JSON_READ_CHAR_EOF = 0x7ffffff0;
 
+  struct Scope {
+    std::string parent_object_key;
+    absl::variant<Json::Object, Json::Array> data;
+
+    Json::Type type() const {
+      return Match(
+          data, [](const Json::Object&) { return Json::Type::kObject; },
+          [](const Json::Array&) { return Json::Type::kArray; });
+    }
+
+    Json TakeAsJson() {
+      return MatchMutable(
+          &data, [&](Json::Object* object) { return Json(std::move(*object)); },
+          [&](Json::Array* array) { return Json(std::move(*array)); });
+    }
+  };
+
   explicit JsonReader(absl::string_view input)
       : original_input_(reinterpret_cast<const uint8_t*>(input.data())),
         input_(original_input_),
@@ -132,7 +151,7 @@ class JsonReader {
   uint8_t utf8_first_byte_ = 0;
 
   Json root_value_;
-  std::vector<Json*> stack_;
+  std::vector<Scope> stack_;
 
   std::string key_;
   std::string string_;
@@ -229,28 +248,14 @@ uint32_t JsonReader::ReadChar() {
 }
 
 Json* JsonReader::CreateAndLinkValue() {
-  Json* value;
-  if (stack_.empty()) {
-    value = &root_value_;
-  } else {
-    Json* parent = stack_.back();
-    if (parent->type() == Json::Type::OBJECT) {
-      if (parent->object_value().find(key_) != parent->object_value().end()) {
-        if (errors_.size() == GRPC_JSON_MAX_ERRORS) {
-          truncated_errors_ = true;
-        } else {
-          errors_.push_back(absl::StrFormat(
-              "duplicate key \"%s\" at index %" PRIuPTR, key_, CurrentIndex()));
-        }
-      }
-      value = &(*parent->mutable_object())[std::move(key_)];
-    } else {
-      GPR_ASSERT(parent->type() == Json::Type::ARRAY);
-      parent->mutable_array()->emplace_back();
-      value = &parent->mutable_array()->back();
-    }
-  }
-  return value;
+  if (stack_.empty()) return &root_value_;
+  return MatchMutable(
+      &stack_.back().data,
+      [&](Json::Object* object) { return &(*object)[std::move(key_)]; },
+      [&](Json::Array* array) {
+        array->emplace_back();
+        return &array->back();
+      });
 }
 
 bool JsonReader::StartContainer(Json::Type type) {
@@ -264,25 +269,40 @@ bool JsonReader::StartContainer(Json::Type type) {
     }
     return false;
   }
-  Json* value = CreateAndLinkValue();
-  if (type == Json::Type::OBJECT) {
-    *value = Json::Object();
+  stack_.emplace_back();
+  Scope& scope = stack_.back();
+  scope.parent_object_key = std::move(key_);
+  if (type == Json::Type::kObject) {
+    scope.data = Json::Object();
   } else {
-    GPR_ASSERT(type == Json::Type::ARRAY);
-    *value = Json::Array();
+    GPR_ASSERT(type == Json::Type::kArray);
+    scope.data = Json::Array();
   }
-  stack_.push_back(value);
   return true;
 }
 
 void JsonReader::EndContainer() {
   GPR_ASSERT(!stack_.empty());
+  Scope scope = std::move(stack_.back());
   stack_.pop_back();
+  key_ = std::move(scope.parent_object_key);
+  Json* value = CreateAndLinkValue();
+  *value = scope.TakeAsJson();
 }
 
 void JsonReader::SetKey() {
   key_ = std::move(string_);
   string_.clear();
+  const Json::Object& object = absl::get<Json::Object>(stack_.back().data);
+  if (object.find(key_) != object.end()) {
+    if (errors_.size() == GRPC_JSON_MAX_ERRORS) {
+      truncated_errors_ = true;
+    } else {
+      errors_.push_back(
+          absl::StrFormat("duplicate key \"%s\" at index %" PRIuPTR, key_,
+                          CurrentIndex() - key_.size() - 2));
+    }
+  }
 }
 
 void JsonReader::SetString() {
@@ -405,9 +425,9 @@ JsonReader::Status JsonReader::Run() {
             if (stack_.empty()) {
               return Status::GRPC_JSON_PARSE_ERROR;
             } else if (c == '}' &&
-                       stack_.back()->type() != Json::Type::OBJECT) {
+                       stack_.back().type() != Json::Type::kObject) {
               return Status::GRPC_JSON_PARSE_ERROR;
-            } else if (c == ']' && stack_.back()->type() != Json::Type::ARRAY) {
+            } else if (c == ']' && stack_.back().type() != Json::Type::kArray) {
               return Status::GRPC_JSON_PARSE_ERROR;
             }
             if (!SetNumber()) return Status::GRPC_JSON_PARSE_ERROR;
@@ -422,10 +442,10 @@ JsonReader::Status JsonReader::Run() {
                 return Status::GRPC_JSON_PARSE_ERROR;
               }
               if (!stack_.empty() &&
-                  stack_.back()->type() == Json::Type::OBJECT) {
+                  stack_.back().type() == Json::Type::kObject) {
                 state_ = State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN;
               } else if (!stack_.empty() &&
-                         stack_.back()->type() == Json::Type::ARRAY) {
+                         stack_.back().type() == Json::Type::kArray) {
                 state_ = State::GRPC_JSON_STATE_VALUE_BEGIN;
               } else {
                 return Status::GRPC_JSON_PARSE_ERROR;
@@ -434,7 +454,7 @@ JsonReader::Status JsonReader::Run() {
               if (stack_.empty()) {
                 return Status::GRPC_JSON_PARSE_ERROR;
               }
-              if (c == '}' && stack_.back()->type() != Json::Type::OBJECT) {
+              if (c == '}' && stack_.back().type() != Json::Type::kObject) {
                 return Status::GRPC_JSON_PARSE_ERROR;
               }
               if (c == '}' &&
@@ -442,7 +462,7 @@ JsonReader::Status JsonReader::Run() {
                   !container_just_begun_) {
                 return Status::GRPC_JSON_PARSE_ERROR;
               }
-              if (c == ']' && stack_.back()->type() != Json::Type::ARRAY) {
+              if (c == ']' && stack_.back().type() != Json::Type::kArray) {
                 return Status::GRPC_JSON_PARSE_ERROR;
               }
               if (c == ']' && state_ == State::GRPC_JSON_STATE_VALUE_BEGIN &&
@@ -581,7 +601,7 @@ JsonReader::Status JsonReader::Run() {
 
               case '{':
                 container_just_begun_ = true;
-                if (!StartContainer(Json::Type::OBJECT)) {
+                if (!StartContainer(Json::Type::kObject)) {
                   return Status::GRPC_JSON_PARSE_ERROR;
                 }
                 state_ = State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN;
@@ -589,7 +609,7 @@ JsonReader::Status JsonReader::Run() {
 
               case '[':
                 container_just_begun_ = true;
-                if (!StartContainer(Json::Type::ARRAY)) {
+                if (!StartContainer(Json::Type::kArray)) {
                   return Status::GRPC_JSON_PARSE_ERROR;
                 }
                 break;
@@ -923,7 +943,7 @@ absl::StatusOr<Json> JsonReader::Parse(absl::string_view input) {
 
 }  // namespace
 
-absl::StatusOr<Json> Json::Parse(absl::string_view json_str) {
+absl::StatusOr<Json> JsonParse(absl::string_view json_str) {
   return JsonReader::Parse(json_str);
 }
 

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

@@ -0,0 +1,34 @@
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_SRC_CORE_LIB_JSON_JSON_READER_H
+#define GRPC_SRC_CORE_LIB_JSON_JSON_READER_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/json/json.h"
+
+namespace grpc_core {
+
+// Parses JSON string from json_str.
+absl::StatusOr<Json> JsonParse(absl::string_view json_str);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_JSON_JSON_READER_H