grpc 1.21.0 → 1.32.0

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

@@ -20,96 +20,267 @@
 
 #include <string.h>
 
-#include <grpc/support/log.h>
+#include <string>
 
-#include "src/core/lib/json/json_reader.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 
-static void json_reader_string_clear(grpc_json_reader* reader) {
-  reader->vtable->string_clear(reader->userdata);
-}
+#include <grpc/support/log.h>
 
-static void json_reader_string_add_char(grpc_json_reader* reader, uint32_t c) {
-  reader->vtable->string_add_char(reader->userdata, c);
+#include "src/core/lib/json/json.h"
+
+#define GRPC_JSON_MAX_DEPTH 255
+#define GRPC_JSON_MAX_ERRORS 16
+
+namespace grpc_core {
+
+namespace {
+
+class JsonReader {
+ public:
+  static grpc_error* Parse(absl::string_view input, Json* output);
+
+ private:
+  enum class Status {
+    GRPC_JSON_DONE,          /* The parser finished successfully. */
+    GRPC_JSON_PARSE_ERROR,   /* The parser found an error in the json stream. */
+    GRPC_JSON_INTERNAL_ERROR /* The parser got an internal error. */
+  };
+
+  enum class State {
+    GRPC_JSON_STATE_OBJECT_KEY_BEGIN,
+    GRPC_JSON_STATE_OBJECT_KEY_STRING,
+    GRPC_JSON_STATE_OBJECT_KEY_END,
+    GRPC_JSON_STATE_VALUE_BEGIN,
+    GRPC_JSON_STATE_VALUE_STRING,
+    GRPC_JSON_STATE_STRING_ESCAPE,
+    GRPC_JSON_STATE_STRING_ESCAPE_U1,
+    GRPC_JSON_STATE_STRING_ESCAPE_U2,
+    GRPC_JSON_STATE_STRING_ESCAPE_U3,
+    GRPC_JSON_STATE_STRING_ESCAPE_U4,
+    GRPC_JSON_STATE_VALUE_NUMBER,
+    GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL,
+    GRPC_JSON_STATE_VALUE_NUMBER_ZERO,
+    GRPC_JSON_STATE_VALUE_NUMBER_DOT,
+    GRPC_JSON_STATE_VALUE_NUMBER_E,
+    GRPC_JSON_STATE_VALUE_NUMBER_EPM,
+    GRPC_JSON_STATE_VALUE_TRUE_R,
+    GRPC_JSON_STATE_VALUE_TRUE_U,
+    GRPC_JSON_STATE_VALUE_TRUE_E,
+    GRPC_JSON_STATE_VALUE_FALSE_A,
+    GRPC_JSON_STATE_VALUE_FALSE_L,
+    GRPC_JSON_STATE_VALUE_FALSE_S,
+    GRPC_JSON_STATE_VALUE_FALSE_E,
+    GRPC_JSON_STATE_VALUE_NULL_U,
+    GRPC_JSON_STATE_VALUE_NULL_L1,
+    GRPC_JSON_STATE_VALUE_NULL_L2,
+    GRPC_JSON_STATE_VALUE_END,
+    GRPC_JSON_STATE_END
+  };
+
+  /* The first non-unicode value is 0x110000. But let's pick
+   * a value high enough to start our error codes from. These
+   * values are safe to return from the read_char function.
+   */
+  static constexpr uint32_t GRPC_JSON_READ_CHAR_EOF = 0x7ffffff0;
+
+  explicit JsonReader(absl::string_view input)
+      : original_input_(reinterpret_cast<const uint8_t*>(input.data())),
+        input_(original_input_),
+        remaining_input_(input.size()) {}
+
+  Status Run();
+  uint32_t ReadChar();
+  bool IsComplete();
+
+  size_t CurrentIndex() const { return input_ - original_input_ - 1; }
+
+  void StringAddChar(uint32_t c);
+  void StringAddUtf32(uint32_t c);
+
+  Json* CreateAndLinkValue();
+  bool StartContainer(Json::Type type);
+  void EndContainer();
+  void SetKey();
+  void SetString();
+  bool SetNumber();
+  void SetTrue();
+  void SetFalse();
+  void SetNull();
+
+  const uint8_t* original_input_;
+  const uint8_t* input_;
+  size_t remaining_input_;
+
+  State state_ = State::GRPC_JSON_STATE_VALUE_BEGIN;
+  bool escaped_string_was_key_ = false;
+  bool container_just_begun_ = false;
+  uint16_t unicode_char_ = 0;
+  uint16_t unicode_high_surrogate_ = 0;
+  std::vector<grpc_error*> errors_;
+  bool truncated_errors_ = false;
+
+  Json root_value_;
+  std::vector<Json*> stack_;
+
+  std::string key_;
+  std::string string_;
+};
+
+void JsonReader::StringAddChar(uint32_t c) {
+  string_.push_back(static_cast<uint8_t>(c));
 }
 
-static void json_reader_string_add_utf32(grpc_json_reader* reader,
-                                         uint32_t utf32) {
-  reader->vtable->string_add_utf32(reader->userdata, utf32);
+void JsonReader::StringAddUtf32(uint32_t c) {
+  if (c <= 0x7f) {
+    StringAddChar(c);
+  } else if (c <= 0x7ff) {
+    uint32_t b1 = 0xc0 | ((c >> 6) & 0x1f);
+    uint32_t b2 = 0x80 | (c & 0x3f);
+    StringAddChar(b1);
+    StringAddChar(b2);
+  } else if (c <= 0xffff) {
+    uint32_t b1 = 0xe0 | ((c >> 12) & 0x0f);
+    uint32_t b2 = 0x80 | ((c >> 6) & 0x3f);
+    uint32_t b3 = 0x80 | (c & 0x3f);
+    StringAddChar(b1);
+    StringAddChar(b2);
+    StringAddChar(b3);
+  } else if (c <= 0x1fffff) {
+    uint32_t b1 = 0xf0 | ((c >> 18) & 0x07);
+    uint32_t b2 = 0x80 | ((c >> 12) & 0x3f);
+    uint32_t b3 = 0x80 | ((c >> 6) & 0x3f);
+    uint32_t b4 = 0x80 | (c & 0x3f);
+    StringAddChar(b1);
+    StringAddChar(b2);
+    StringAddChar(b3);
+    StringAddChar(b4);
+  }
 }
 
-static uint32_t grpc_json_reader_read_char(grpc_json_reader* reader) {
-  return reader->vtable->read_char(reader->userdata);
+uint32_t JsonReader::ReadChar() {
+  if (remaining_input_ == 0) return GRPC_JSON_READ_CHAR_EOF;
+  const uint32_t r = *input_++;
+  --remaining_input_;
+  if (r == 0) {
+    remaining_input_ = 0;
+    return GRPC_JSON_READ_CHAR_EOF;
+  }
+  return r;
 }
 
-static void json_reader_container_begins(grpc_json_reader* reader,
-                                         grpc_json_type type) {
-  reader->vtable->container_begins(reader->userdata, type);
+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(GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+              absl::StrFormat("duplicate key \"%s\" at index %" PRIuPTR, key_,
+                              CurrentIndex())
+                  .c_str()));
+        }
+      }
+      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;
 }
 
-static grpc_json_type grpc_json_reader_container_ends(
-    grpc_json_reader* reader) {
-  return reader->vtable->container_ends(reader->userdata);
+bool JsonReader::StartContainer(Json::Type type) {
+  if (stack_.size() == GRPC_JSON_MAX_DEPTH) {
+    if (errors_.size() == GRPC_JSON_MAX_ERRORS) {
+      truncated_errors_ = true;
+    } else {
+      errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+          absl::StrFormat("exceeded max stack depth (%d) at index %" PRIuPTR,
+                          GRPC_JSON_MAX_DEPTH, CurrentIndex())
+              .c_str()));
+    }
+    return false;
+  }
+  Json* value = CreateAndLinkValue();
+  if (type == Json::Type::OBJECT) {
+    *value = Json::Object();
+  } else {
+    GPR_ASSERT(type == Json::Type::ARRAY);
+    *value = Json::Array();
+  }
+  stack_.push_back(value);
+  return true;
 }
 
-static void json_reader_set_key(grpc_json_reader* reader) {
-  reader->vtable->set_key(reader->userdata);
+void JsonReader::EndContainer() {
+  GPR_ASSERT(!stack_.empty());
+  stack_.pop_back();
 }
 
-static void json_reader_set_string(grpc_json_reader* reader) {
-  reader->vtable->set_string(reader->userdata);
+void JsonReader::SetKey() {
+  key_ = std::move(string_);
+  string_.clear();
 }
 
-static int json_reader_set_number(grpc_json_reader* reader) {
-  return reader->vtable->set_number(reader->userdata);
+void JsonReader::SetString() {
+  Json* value = CreateAndLinkValue();
+  *value = std::move(string_);
+  string_.clear();
 }
 
-static void json_reader_set_true(grpc_json_reader* reader) {
-  reader->vtable->set_true(reader->userdata);
+bool JsonReader::SetNumber() {
+  Json* value = CreateAndLinkValue();
+  *value = Json(string_, /*is_number=*/true);
+  string_.clear();
+  return true;
 }
 
-static void json_reader_set_false(grpc_json_reader* reader) {
-  reader->vtable->set_false(reader->userdata);
+void JsonReader::SetTrue() {
+  Json* value = CreateAndLinkValue();
+  *value = true;
+  string_.clear();
 }
 
-static void json_reader_set_null(grpc_json_reader* reader) {
-  reader->vtable->set_null(reader->userdata);
+void JsonReader::SetFalse() {
+  Json* value = CreateAndLinkValue();
+  *value = false;
+  string_.clear();
 }
 
-/* Call this function to initialize the reader structure. */
-void grpc_json_reader_init(grpc_json_reader* reader,
-                           grpc_json_reader_vtable* vtable, void* userdata) {
-  memset(reader, 0, sizeof(*reader));
-  reader->vtable = vtable;
-  reader->userdata = userdata;
-  json_reader_string_clear(reader);
-  reader->state = GRPC_JSON_STATE_VALUE_BEGIN;
-}
+void JsonReader::SetNull() { CreateAndLinkValue(); }
 
-int grpc_json_reader_is_complete(grpc_json_reader* reader) {
-  return ((reader->depth == 0) &&
-          ((reader->state == GRPC_JSON_STATE_END) ||
-           (reader->state == GRPC_JSON_STATE_VALUE_END)));
+bool JsonReader::IsComplete() {
+  return (stack_.empty() && (state_ == State::GRPC_JSON_STATE_END ||
+                             state_ == State::GRPC_JSON_STATE_VALUE_END));
 }
 
-grpc_json_reader_status grpc_json_reader_run(grpc_json_reader* reader) {
-  uint32_t c, success;
+/* Call this function to start parsing the input. It will return the following:
+ *    . GRPC_JSON_DONE if the input got eof, and the parsing finished
+ *      successfully.
+ *    . GRPC_JSON_PARSE_ERROR if the input was somehow invalid.
+ *    . GRPC_JSON_INTERNAL_ERROR if the parser somehow ended into an invalid
+ *      internal state.
+ */
+JsonReader::Status JsonReader::Run() {
+  uint32_t c;
 
   /* This state-machine is a strict implementation of ECMA-404 */
-  for (;;) {
-    c = grpc_json_reader_read_char(reader);
+  while (true) {
+    c = ReadChar();
     switch (c) {
-      /* Let's process the error cases first. */
-      case GRPC_JSON_READ_CHAR_ERROR:
-        return GRPC_JSON_READ_ERROR;
-
-      case GRPC_JSON_READ_CHAR_EAGAIN:
-        return GRPC_JSON_EAGAIN;
-
+      /* Let's process the error case first. */
       case GRPC_JSON_READ_CHAR_EOF:
-        if (grpc_json_reader_is_complete(reader)) {
-          return GRPC_JSON_DONE;
+        if (IsComplete()) {
+          return Status::GRPC_JSON_DONE;
         } else {
-          return GRPC_JSON_PARSE_ERROR;
+          return Status::GRPC_JSON_PARSE_ERROR;
         }
         break;
 
@@ -118,34 +289,33 @@ grpc_json_reader_status grpc_json_reader_run(grpc_json_reader* reader) {
       case '\t':
       case '\n':
       case '\r':
-        switch (reader->state) {
-          case GRPC_JSON_STATE_OBJECT_KEY_BEGIN:
-          case GRPC_JSON_STATE_OBJECT_KEY_END:
-          case GRPC_JSON_STATE_VALUE_BEGIN:
-          case GRPC_JSON_STATE_VALUE_END:
-          case GRPC_JSON_STATE_END:
-            break;
-
-          case GRPC_JSON_STATE_OBJECT_KEY_STRING:
-          case GRPC_JSON_STATE_VALUE_STRING:
-            if (c != ' ') return GRPC_JSON_PARSE_ERROR;
-            if (reader->unicode_high_surrogate != 0)
-              return GRPC_JSON_PARSE_ERROR;
-            json_reader_string_add_char(reader, c);
+        switch (state_) {
+          case State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN:
+          case State::GRPC_JSON_STATE_OBJECT_KEY_END:
+          case State::GRPC_JSON_STATE_VALUE_BEGIN:
+          case State::GRPC_JSON_STATE_VALUE_END:
+          case State::GRPC_JSON_STATE_END:
+            break;
+
+          case State::GRPC_JSON_STATE_OBJECT_KEY_STRING:
+          case State::GRPC_JSON_STATE_VALUE_STRING:
+            if (c != ' ') return Status::GRPC_JSON_PARSE_ERROR;
+            if (unicode_high_surrogate_ != 0) {
+              return Status::GRPC_JSON_PARSE_ERROR;
+            }
+            StringAddChar(c);
             break;
 
-          case GRPC_JSON_STATE_VALUE_NUMBER:
-          case GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL:
-          case GRPC_JSON_STATE_VALUE_NUMBER_ZERO:
-          case GRPC_JSON_STATE_VALUE_NUMBER_EPM:
-            success = static_cast<uint32_t>(json_reader_set_number(reader));
-            if (!success) return GRPC_JSON_PARSE_ERROR;
-            json_reader_string_clear(reader);
-            reader->state = GRPC_JSON_STATE_VALUE_END;
+          case State::GRPC_JSON_STATE_VALUE_NUMBER:
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL:
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_ZERO:
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_EPM:
+            if (!SetNumber()) return Status::GRPC_JSON_PARSE_ERROR;
+            state_ = State::GRPC_JSON_STATE_VALUE_END;
             break;
 
           default:
-            return GRPC_JSON_PARSE_ERROR;
+            return Status::GRPC_JSON_PARSE_ERROR;
         }
         break;
 
@@ -153,182 +323,171 @@ grpc_json_reader_status grpc_json_reader_run(grpc_json_reader* reader) {
       case ',':
       case '}':
       case ']':
-        switch (reader->state) {
-          case GRPC_JSON_STATE_OBJECT_KEY_STRING:
-          case GRPC_JSON_STATE_VALUE_STRING:
-            if (reader->unicode_high_surrogate != 0) {
-              return GRPC_JSON_PARSE_ERROR;
+        switch (state_) {
+          case State::GRPC_JSON_STATE_OBJECT_KEY_STRING:
+          case State::GRPC_JSON_STATE_VALUE_STRING:
+            if (unicode_high_surrogate_ != 0) {
+              return Status::GRPC_JSON_PARSE_ERROR;
             }
-            json_reader_string_add_char(reader, c);
-            break;
-
-          case GRPC_JSON_STATE_VALUE_NUMBER:
-          case GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL:
-          case GRPC_JSON_STATE_VALUE_NUMBER_ZERO:
-          case GRPC_JSON_STATE_VALUE_NUMBER_EPM:
-            if (reader->depth == 0) {
-              return GRPC_JSON_PARSE_ERROR;
-            } else if ((c == '}') && !reader->in_object) {
-              return GRPC_JSON_PARSE_ERROR;
-            } else if ((c == ']') && !reader->in_array) {
-              return GRPC_JSON_PARSE_ERROR;
+            StringAddChar(c);
+            break;
+
+          case State::GRPC_JSON_STATE_VALUE_NUMBER:
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL:
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_ZERO:
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_EPM:
+            if (stack_.empty()) {
+              return Status::GRPC_JSON_PARSE_ERROR;
+            } else if (c == '}' &&
+                       stack_.back()->type() != Json::Type::OBJECT) {
+              return Status::GRPC_JSON_PARSE_ERROR;
+              return Status::GRPC_JSON_PARSE_ERROR;
+            } else if (c == ']' && stack_.back()->type() != Json::Type::ARRAY) {
+              return Status::GRPC_JSON_PARSE_ERROR;
             }
-            success = static_cast<uint32_t>(json_reader_set_number(reader));
-            if (!success) return GRPC_JSON_PARSE_ERROR;
-            json_reader_string_clear(reader);
-            reader->state = GRPC_JSON_STATE_VALUE_END;
+            if (!SetNumber()) return Status::GRPC_JSON_PARSE_ERROR;
+            state_ = State::GRPC_JSON_STATE_VALUE_END;
             /* The missing break here is intentional. */
             /* fallthrough */
 
-          case GRPC_JSON_STATE_VALUE_END:
-          case GRPC_JSON_STATE_OBJECT_KEY_BEGIN:
-          case GRPC_JSON_STATE_VALUE_BEGIN:
+          case State::GRPC_JSON_STATE_VALUE_END:
+          case State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN:
+          case State::GRPC_JSON_STATE_VALUE_BEGIN:
             if (c == ',') {
-              if (reader->state != GRPC_JSON_STATE_VALUE_END) {
-                return GRPC_JSON_PARSE_ERROR;
+              if (state_ != State::GRPC_JSON_STATE_VALUE_END) {
+                return Status::GRPC_JSON_PARSE_ERROR;
               }
-              if (reader->in_object) {
-                reader->state = GRPC_JSON_STATE_OBJECT_KEY_BEGIN;
-              } else if (reader->in_array) {
-                reader->state = GRPC_JSON_STATE_VALUE_BEGIN;
+              if (!stack_.empty() &&
+                  stack_.back()->type() == Json::Type::OBJECT) {
+                state_ = State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN;
+              } else if (!stack_.empty() &&
+                         stack_.back()->type() == Json::Type::ARRAY) {
+                state_ = State::GRPC_JSON_STATE_VALUE_BEGIN;
               } else {
-                return GRPC_JSON_PARSE_ERROR;
+                return Status::GRPC_JSON_PARSE_ERROR;
               }
             } else {
-              if (reader->depth-- == 0) return GRPC_JSON_PARSE_ERROR;
-              if ((c == '}') && !reader->in_object) {
-                return GRPC_JSON_PARSE_ERROR;
+              if (stack_.empty()) {
+                return Status::GRPC_JSON_PARSE_ERROR;
+              }
+              if (c == '}' && stack_.back()->type() != Json::Type::OBJECT) {
+                return Status::GRPC_JSON_PARSE_ERROR;
+              }
+              if (c == '}' &&
+                  state_ == State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN &&
+                  !container_just_begun_) {
+                return Status::GRPC_JSON_PARSE_ERROR;
               }
-              if ((c == '}') &&
-                  (reader->state == GRPC_JSON_STATE_OBJECT_KEY_BEGIN) &&
-                  !reader->container_just_begun) {
-                return GRPC_JSON_PARSE_ERROR;
+              if (c == ']' && stack_.back()->type() != Json::Type::ARRAY) {
+                return Status::GRPC_JSON_PARSE_ERROR;
               }
-              if ((c == ']') && !reader->in_array) return GRPC_JSON_PARSE_ERROR;
-              if ((c == ']') &&
-                  (reader->state == GRPC_JSON_STATE_VALUE_BEGIN) &&
-                  !reader->container_just_begun) {
-                return GRPC_JSON_PARSE_ERROR;
+              if (c == ']' && state_ == State::GRPC_JSON_STATE_VALUE_BEGIN &&
+                  !container_just_begun_) {
+                return Status::GRPC_JSON_PARSE_ERROR;
               }
-              reader->state = GRPC_JSON_STATE_VALUE_END;
-              switch (grpc_json_reader_container_ends(reader)) {
-                case GRPC_JSON_OBJECT:
-                  reader->in_object = 1;
-                  reader->in_array = 0;
-                  break;
-                case GRPC_JSON_ARRAY:
-                  reader->in_object = 0;
-                  reader->in_array = 1;
-                  break;
-                case GRPC_JSON_TOP_LEVEL:
-                  GPR_ASSERT(reader->depth == 0);
-                  reader->in_object = 0;
-                  reader->in_array = 0;
-                  reader->state = GRPC_JSON_STATE_END;
-                  break;
-                default:
-                  GPR_UNREACHABLE_CODE(return GRPC_JSON_INTERNAL_ERROR);
+              state_ = State::GRPC_JSON_STATE_VALUE_END;
+              EndContainer();
+              if (stack_.empty()) {
+                state_ = State::GRPC_JSON_STATE_END;
               }
             }
             break;
 
           default:
-            return GRPC_JSON_PARSE_ERROR;
+            return Status::GRPC_JSON_PARSE_ERROR;
         }
         break;
 
       /* In-string escaping. */
       case '\\':
-        switch (reader->state) {
-          case GRPC_JSON_STATE_OBJECT_KEY_STRING:
-            reader->escaped_string_was_key = 1;
-            reader->state = GRPC_JSON_STATE_STRING_ESCAPE;
+        switch (state_) {
+          case State::GRPC_JSON_STATE_OBJECT_KEY_STRING:
+            escaped_string_was_key_ = true;
+            state_ = State::GRPC_JSON_STATE_STRING_ESCAPE;
             break;
 
-          case GRPC_JSON_STATE_VALUE_STRING:
-            reader->escaped_string_was_key = 0;
-            reader->state = GRPC_JSON_STATE_STRING_ESCAPE;
+          case State::GRPC_JSON_STATE_VALUE_STRING:
+            escaped_string_was_key_ = false;
+            state_ = State::GRPC_JSON_STATE_STRING_ESCAPE;
             break;
 
           /* This is the \\ case. */
-          case GRPC_JSON_STATE_STRING_ESCAPE:
-            if (reader->unicode_high_surrogate != 0)
-              return GRPC_JSON_PARSE_ERROR;
-            json_reader_string_add_char(reader, '\\');
-            if (reader->escaped_string_was_key) {
-              reader->state = GRPC_JSON_STATE_OBJECT_KEY_STRING;
+          case State::GRPC_JSON_STATE_STRING_ESCAPE:
+            if (unicode_high_surrogate_ != 0)
+              return Status::GRPC_JSON_PARSE_ERROR;
+            StringAddChar('\\');
+            if (escaped_string_was_key_) {
+              state_ = State::GRPC_JSON_STATE_OBJECT_KEY_STRING;
             } else {
-              reader->state = GRPC_JSON_STATE_VALUE_STRING;
+              state_ = State::GRPC_JSON_STATE_VALUE_STRING;
             }
             break;
 
           default:
-            return GRPC_JSON_PARSE_ERROR;
+            return Status::GRPC_JSON_PARSE_ERROR;
         }
         break;
 
       default:
-        reader->container_just_begun = 0;
-        switch (reader->state) {
-          case GRPC_JSON_STATE_OBJECT_KEY_BEGIN:
-            if (c != '"') return GRPC_JSON_PARSE_ERROR;
-            reader->state = GRPC_JSON_STATE_OBJECT_KEY_STRING;
+        container_just_begun_ = false;
+        switch (state_) {
+          case State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN:
+            if (c != '"') return Status::GRPC_JSON_PARSE_ERROR;
+            state_ = State::GRPC_JSON_STATE_OBJECT_KEY_STRING;
             break;
 
-          case GRPC_JSON_STATE_OBJECT_KEY_STRING:
-            if (reader->unicode_high_surrogate != 0) {
-              return GRPC_JSON_PARSE_ERROR;
+          case State::GRPC_JSON_STATE_OBJECT_KEY_STRING:
+            if (unicode_high_surrogate_ != 0) {
+              return Status::GRPC_JSON_PARSE_ERROR;
             }
             if (c == '"') {
-              reader->state = GRPC_JSON_STATE_OBJECT_KEY_END;
-              json_reader_set_key(reader);
-              json_reader_string_clear(reader);
+              state_ = State::GRPC_JSON_STATE_OBJECT_KEY_END;
+              SetKey();
             } else {
-              if (c < 32) return GRPC_JSON_PARSE_ERROR;
-              json_reader_string_add_char(reader, c);
+              if (c < 32) return Status::GRPC_JSON_PARSE_ERROR;
+              StringAddChar(c);
             }
             break;
 
-          case GRPC_JSON_STATE_VALUE_STRING:
-            if (reader->unicode_high_surrogate != 0) {
-              return GRPC_JSON_PARSE_ERROR;
+          case State::GRPC_JSON_STATE_VALUE_STRING:
+            if (unicode_high_surrogate_ != 0) {
+              return Status::GRPC_JSON_PARSE_ERROR;
             }
             if (c == '"') {
-              reader->state = GRPC_JSON_STATE_VALUE_END;
-              json_reader_set_string(reader);
-              json_reader_string_clear(reader);
+              state_ = State::GRPC_JSON_STATE_VALUE_END;
+              SetString();
             } else {
-              if (c < 32) return GRPC_JSON_PARSE_ERROR;
-              json_reader_string_add_char(reader, c);
+              if (c < 32) return Status::GRPC_JSON_PARSE_ERROR;
+              StringAddChar(c);
             }
             break;
 
-          case GRPC_JSON_STATE_OBJECT_KEY_END:
-            if (c != ':') return GRPC_JSON_PARSE_ERROR;
-            reader->state = GRPC_JSON_STATE_VALUE_BEGIN;
+          case State::GRPC_JSON_STATE_OBJECT_KEY_END:
+            if (c != ':') return Status::GRPC_JSON_PARSE_ERROR;
+            state_ = State::GRPC_JSON_STATE_VALUE_BEGIN;
             break;
 
-          case GRPC_JSON_STATE_VALUE_BEGIN:
+          case State::GRPC_JSON_STATE_VALUE_BEGIN:
             switch (c) {
               case 't':
-                reader->state = GRPC_JSON_STATE_VALUE_TRUE_R;
+                state_ = State::GRPC_JSON_STATE_VALUE_TRUE_R;
                 break;
 
               case 'f':
-                reader->state = GRPC_JSON_STATE_VALUE_FALSE_A;
+                state_ = State::GRPC_JSON_STATE_VALUE_FALSE_A;
                 break;
 
               case 'n':
-                reader->state = GRPC_JSON_STATE_VALUE_NULL_U;
+                state_ = State::GRPC_JSON_STATE_VALUE_NULL_U;
                 break;
 
               case '"':
-                reader->state = GRPC_JSON_STATE_VALUE_STRING;
+                state_ = State::GRPC_JSON_STATE_VALUE_STRING;
                 break;
 
               case '0':
-                json_reader_string_add_char(reader, c);
-                reader->state = GRPC_JSON_STATE_VALUE_NUMBER_ZERO;
+                StringAddChar(c);
+                state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_ZERO;
                 break;
 
               case '1':
@@ -341,73 +500,71 @@ grpc_json_reader_status grpc_json_reader_run(grpc_json_reader* reader) {
               case '8':
               case '9':
               case '-':
-                json_reader_string_add_char(reader, c);
-                reader->state = GRPC_JSON_STATE_VALUE_NUMBER;
+                StringAddChar(c);
+                state_ = State::GRPC_JSON_STATE_VALUE_NUMBER;
                 break;
 
               case '{':
-                reader->container_just_begun = 1;
-                json_reader_container_begins(reader, GRPC_JSON_OBJECT);
-                reader->depth++;
-                reader->state = GRPC_JSON_STATE_OBJECT_KEY_BEGIN;
-                reader->in_object = 1;
-                reader->in_array = 0;
+                container_just_begun_ = true;
+                if (!StartContainer(Json::Type::OBJECT)) {
+                  return Status::GRPC_JSON_PARSE_ERROR;
+                }
+                state_ = State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN;
                 break;
 
               case '[':
-                reader->container_just_begun = 1;
-                json_reader_container_begins(reader, GRPC_JSON_ARRAY);
-                reader->depth++;
-                reader->in_object = 0;
-                reader->in_array = 1;
+                container_just_begun_ = true;
+                if (!StartContainer(Json::Type::ARRAY)) {
+                  return Status::GRPC_JSON_PARSE_ERROR;
+                }
                 break;
               default:
-                return GRPC_JSON_PARSE_ERROR;
+                return Status::GRPC_JSON_PARSE_ERROR;
             }
             break;
 
-          case GRPC_JSON_STATE_STRING_ESCAPE:
-            if (reader->escaped_string_was_key) {
-              reader->state = GRPC_JSON_STATE_OBJECT_KEY_STRING;
+          case State::GRPC_JSON_STATE_STRING_ESCAPE:
+            if (escaped_string_was_key_) {
+              state_ = State::GRPC_JSON_STATE_OBJECT_KEY_STRING;
             } else {
-              reader->state = GRPC_JSON_STATE_VALUE_STRING;
+              state_ = State::GRPC_JSON_STATE_VALUE_STRING;
             }
-            if (reader->unicode_high_surrogate && c != 'u') {
-              return GRPC_JSON_PARSE_ERROR;
+            if (unicode_high_surrogate_ && c != 'u') {
+              return Status::GRPC_JSON_PARSE_ERROR;
             }
             switch (c) {
               case '"':
               case '/':
-                json_reader_string_add_char(reader, c);
+                StringAddChar(c);
                 break;
               case 'b':
-                json_reader_string_add_char(reader, '\b');
+                StringAddChar('\b');
                 break;
               case 'f':
-                json_reader_string_add_char(reader, '\f');
+                StringAddChar('\f');
                 break;
               case 'n':
-                json_reader_string_add_char(reader, '\n');
+                StringAddChar('\n');
                 break;
               case 'r':
-                json_reader_string_add_char(reader, '\r');
+                StringAddChar('\r');
                 break;
               case 't':
-                json_reader_string_add_char(reader, '\t');
+                StringAddChar('\t');
                 break;
               case 'u':
-                reader->state = GRPC_JSON_STATE_STRING_ESCAPE_U1;
-                reader->unicode_char = 0;
+                state_ = State::GRPC_JSON_STATE_STRING_ESCAPE_U1;
+                unicode_char_ = 0;
                 break;
               default:
-                return GRPC_JSON_PARSE_ERROR;
+                return Status::GRPC_JSON_PARSE_ERROR;
             }
             break;
 
-          case GRPC_JSON_STATE_STRING_ESCAPE_U1:
-          case GRPC_JSON_STATE_STRING_ESCAPE_U2:
-          case GRPC_JSON_STATE_STRING_ESCAPE_U3:
-          case GRPC_JSON_STATE_STRING_ESCAPE_U4:
+          case State::GRPC_JSON_STATE_STRING_ESCAPE_U1:
+          case State::GRPC_JSON_STATE_STRING_ESCAPE_U2:
+          case State::GRPC_JSON_STATE_STRING_ESCAPE_U3:
+          case State::GRPC_JSON_STATE_STRING_ESCAPE_U4:
             if ((c >= '0') && (c <= '9')) {
               c -= '0';
             } else if ((c >= 'A') && (c <= 'F')) {
@@ -415,62 +572,60 @@ grpc_json_reader_status grpc_json_reader_run(grpc_json_reader* reader) {
             } else if ((c >= 'a') && (c <= 'f')) {
               c -= 'a' - 10;
             } else {
-              return GRPC_JSON_PARSE_ERROR;
+              return Status::GRPC_JSON_PARSE_ERROR;
             }
-            reader->unicode_char =
-                static_cast<uint16_t>(reader->unicode_char << 4);
-            reader->unicode_char =
-                static_cast<uint16_t>(reader->unicode_char | c);
-
-            switch (reader->state) {
-              case GRPC_JSON_STATE_STRING_ESCAPE_U1:
-                reader->state = GRPC_JSON_STATE_STRING_ESCAPE_U2;
+            unicode_char_ = static_cast<uint16_t>(unicode_char_ << 4);
+            unicode_char_ = static_cast<uint16_t>(unicode_char_ | c);
+
+            switch (state_) {
+              case State::GRPC_JSON_STATE_STRING_ESCAPE_U1:
+                state_ = State::GRPC_JSON_STATE_STRING_ESCAPE_U2;
                 break;
-              case GRPC_JSON_STATE_STRING_ESCAPE_U2:
-                reader->state = GRPC_JSON_STATE_STRING_ESCAPE_U3;
+              case State::GRPC_JSON_STATE_STRING_ESCAPE_U2:
+                state_ = State::GRPC_JSON_STATE_STRING_ESCAPE_U3;
                 break;
-              case GRPC_JSON_STATE_STRING_ESCAPE_U3:
-                reader->state = GRPC_JSON_STATE_STRING_ESCAPE_U4;
+              case State::GRPC_JSON_STATE_STRING_ESCAPE_U3:
+                state_ = State::GRPC_JSON_STATE_STRING_ESCAPE_U4;
                 break;
-              case GRPC_JSON_STATE_STRING_ESCAPE_U4:
+              case State::GRPC_JSON_STATE_STRING_ESCAPE_U4:
                 /* See grpc_json_writer_escape_string to have a description
                  * of what's going on here.
                  */
-                if ((reader->unicode_char & 0xfc00) == 0xd800) {
+                if ((unicode_char_ & 0xfc00) == 0xd800) {
                   /* high surrogate utf-16 */
-                  if (reader->unicode_high_surrogate != 0)
-                    return GRPC_JSON_PARSE_ERROR;
-                  reader->unicode_high_surrogate = reader->unicode_char;
-                } else if ((reader->unicode_char & 0xfc00) == 0xdc00) {
+                  if (unicode_high_surrogate_ != 0)
+                    return Status::GRPC_JSON_PARSE_ERROR;
+                  unicode_high_surrogate_ = unicode_char_;
+                } else if ((unicode_char_ & 0xfc00) == 0xdc00) {
                   /* low surrogate utf-16 */
                   uint32_t utf32;
-                  if (reader->unicode_high_surrogate == 0)
-                    return GRPC_JSON_PARSE_ERROR;
+                  if (unicode_high_surrogate_ == 0)
+                    return Status::GRPC_JSON_PARSE_ERROR;
                   utf32 = 0x10000;
                   utf32 += static_cast<uint32_t>(
-                      (reader->unicode_high_surrogate - 0xd800) * 0x400);
-                  utf32 += static_cast<uint32_t>(reader->unicode_char - 0xdc00);
-                  json_reader_string_add_utf32(reader, utf32);
-                  reader->unicode_high_surrogate = 0;
+                      (unicode_high_surrogate_ - 0xd800) * 0x400);
+                  utf32 += static_cast<uint32_t>(unicode_char_ - 0xdc00);
+                  StringAddUtf32(utf32);
+                  unicode_high_surrogate_ = 0;
                 } else {
                   /* anything else */
-                  if (reader->unicode_high_surrogate != 0)
-                    return GRPC_JSON_PARSE_ERROR;
-                  json_reader_string_add_utf32(reader, reader->unicode_char);
+                  if (unicode_high_surrogate_ != 0)
+                    return Status::GRPC_JSON_PARSE_ERROR;
+                  StringAddUtf32(unicode_char_);
                 }
-                if (reader->escaped_string_was_key) {
-                  reader->state = GRPC_JSON_STATE_OBJECT_KEY_STRING;
+                if (escaped_string_was_key_) {
+                  state_ = State::GRPC_JSON_STATE_OBJECT_KEY_STRING;
                 } else {
-                  reader->state = GRPC_JSON_STATE_VALUE_STRING;
+                  state_ = State::GRPC_JSON_STATE_VALUE_STRING;
                 }
                 break;
               default:
-                GPR_UNREACHABLE_CODE(return GRPC_JSON_INTERNAL_ERROR);
+                GPR_UNREACHABLE_CODE(return Status::GRPC_JSON_INTERNAL_ERROR);
             }
             break;
 
-          case GRPC_JSON_STATE_VALUE_NUMBER:
-            json_reader_string_add_char(reader, c);
+          case State::GRPC_JSON_STATE_VALUE_NUMBER:
+            StringAddChar(c);
             switch (c) {
               case '0':
               case '1':
@@ -485,18 +640,18 @@ grpc_json_reader_status grpc_json_reader_run(grpc_json_reader* reader) {
                 break;
               case 'e':
               case 'E':
-                reader->state = GRPC_JSON_STATE_VALUE_NUMBER_E;
+                state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_E;
                 break;
               case '.':
-                reader->state = GRPC_JSON_STATE_VALUE_NUMBER_DOT;
+                state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_DOT;
                 break;
               default:
-                return GRPC_JSON_PARSE_ERROR;
+                return Status::GRPC_JSON_PARSE_ERROR;
             }
             break;
 
-          case GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL:
-            json_reader_string_add_char(reader, c);
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL:
+            StringAddChar(c);
             switch (c) {
               case '0':
               case '1':
@@ -511,21 +666,21 @@ grpc_json_reader_status grpc_json_reader_run(grpc_json_reader* reader) {
                 break;
               case 'e':
               case 'E':
-                reader->state = GRPC_JSON_STATE_VALUE_NUMBER_E;
+                state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_E;
                 break;
               default:
-                return GRPC_JSON_PARSE_ERROR;
+                return Status::GRPC_JSON_PARSE_ERROR;
             }
             break;
 
-          case GRPC_JSON_STATE_VALUE_NUMBER_ZERO:
-            if (c != '.') return GRPC_JSON_PARSE_ERROR;
-            json_reader_string_add_char(reader, c);
-            reader->state = GRPC_JSON_STATE_VALUE_NUMBER_DOT;
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_ZERO:
+            if (c != '.') return Status::GRPC_JSON_PARSE_ERROR;
+            StringAddChar(c);
+            state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_DOT;
             break;
 
-          case GRPC_JSON_STATE_VALUE_NUMBER_DOT:
-            json_reader_string_add_char(reader, c);
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_DOT:
+            StringAddChar(c);
             switch (c) {
               case '0':
               case '1':
@@ -537,15 +692,15 @@ grpc_json_reader_status grpc_json_reader_run(grpc_json_reader* reader) {
               case '7':
               case '8':
               case '9':
-                reader->state = GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL;
+                state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL;
                 break;
               default:
-                return GRPC_JSON_PARSE_ERROR;
+                return Status::GRPC_JSON_PARSE_ERROR;
             }
             break;
 
-          case GRPC_JSON_STATE_VALUE_NUMBER_E:
-            json_reader_string_add_char(reader, c);
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_E:
+            StringAddChar(c);
             switch (c) {
               case '0':
               case '1':
@@ -559,15 +714,15 @@ grpc_json_reader_status grpc_json_reader_run(grpc_json_reader* reader) {
               case '9':
               case '+':
               case '-':
-                reader->state = GRPC_JSON_STATE_VALUE_NUMBER_EPM;
+                state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_EPM;
                 break;
               default:
-                return GRPC_JSON_PARSE_ERROR;
+                return Status::GRPC_JSON_PARSE_ERROR;
             }
             break;
 
-          case GRPC_JSON_STATE_VALUE_NUMBER_EPM:
-            json_reader_string_add_char(reader, c);
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_EPM:
+            StringAddChar(c);
             switch (c) {
               case '0':
               case '1':
@@ -581,83 +736,119 @@ grpc_json_reader_status grpc_json_reader_run(grpc_json_reader* reader) {
               case '9':
                 break;
               default:
-                return GRPC_JSON_PARSE_ERROR;
+                return Status::GRPC_JSON_PARSE_ERROR;
             }
             break;
 
-          case GRPC_JSON_STATE_VALUE_TRUE_R:
-            if (c != 'r') return GRPC_JSON_PARSE_ERROR;
-            reader->state = GRPC_JSON_STATE_VALUE_TRUE_U;
+          case State::GRPC_JSON_STATE_VALUE_TRUE_R:
+            if (c != 'r') return Status::GRPC_JSON_PARSE_ERROR;
+            state_ = State::GRPC_JSON_STATE_VALUE_TRUE_U;
             break;
 
-          case GRPC_JSON_STATE_VALUE_TRUE_U:
-            if (c != 'u') return GRPC_JSON_PARSE_ERROR;
-            reader->state = GRPC_JSON_STATE_VALUE_TRUE_E;
+          case State::GRPC_JSON_STATE_VALUE_TRUE_U:
+            if (c != 'u') return Status::GRPC_JSON_PARSE_ERROR;
+            state_ = State::GRPC_JSON_STATE_VALUE_TRUE_E;
             break;
 
-          case GRPC_JSON_STATE_VALUE_TRUE_E:
-            if (c != 'e') return GRPC_JSON_PARSE_ERROR;
-            json_reader_set_true(reader);
-            reader->state = GRPC_JSON_STATE_VALUE_END;
+          case State::GRPC_JSON_STATE_VALUE_TRUE_E:
+            if (c != 'e') return Status::GRPC_JSON_PARSE_ERROR;
+            SetTrue();
+            state_ = State::GRPC_JSON_STATE_VALUE_END;
             break;
 
-          case GRPC_JSON_STATE_VALUE_FALSE_A:
-            if (c != 'a') return GRPC_JSON_PARSE_ERROR;
-            reader->state = GRPC_JSON_STATE_VALUE_FALSE_L;
+          case State::GRPC_JSON_STATE_VALUE_FALSE_A:
+            if (c != 'a') return Status::GRPC_JSON_PARSE_ERROR;
+            state_ = State::GRPC_JSON_STATE_VALUE_FALSE_L;
             break;
 
-          case GRPC_JSON_STATE_VALUE_FALSE_L:
-            if (c != 'l') return GRPC_JSON_PARSE_ERROR;
-            reader->state = GRPC_JSON_STATE_VALUE_FALSE_S;
+          case State::GRPC_JSON_STATE_VALUE_FALSE_L:
+            if (c != 'l') return Status::GRPC_JSON_PARSE_ERROR;
+            state_ = State::GRPC_JSON_STATE_VALUE_FALSE_S;
             break;
 
-          case GRPC_JSON_STATE_VALUE_FALSE_S:
-            if (c != 's') return GRPC_JSON_PARSE_ERROR;
-            reader->state = GRPC_JSON_STATE_VALUE_FALSE_E;
+          case State::GRPC_JSON_STATE_VALUE_FALSE_S:
+            if (c != 's') return Status::GRPC_JSON_PARSE_ERROR;
+            state_ = State::GRPC_JSON_STATE_VALUE_FALSE_E;
             break;
 
-          case GRPC_JSON_STATE_VALUE_FALSE_E:
-            if (c != 'e') return GRPC_JSON_PARSE_ERROR;
-            json_reader_set_false(reader);
-            reader->state = GRPC_JSON_STATE_VALUE_END;
+          case State::GRPC_JSON_STATE_VALUE_FALSE_E:
+            if (c != 'e') return Status::GRPC_JSON_PARSE_ERROR;
+            SetFalse();
+            state_ = State::GRPC_JSON_STATE_VALUE_END;
             break;
 
-          case GRPC_JSON_STATE_VALUE_NULL_U:
-            if (c != 'u') return GRPC_JSON_PARSE_ERROR;
-            reader->state = GRPC_JSON_STATE_VALUE_NULL_L1;
+          case State::GRPC_JSON_STATE_VALUE_NULL_U:
+            if (c != 'u') return Status::GRPC_JSON_PARSE_ERROR;
+            state_ = State::GRPC_JSON_STATE_VALUE_NULL_L1;
             break;
 
-          case GRPC_JSON_STATE_VALUE_NULL_L1:
-            if (c != 'l') return GRPC_JSON_PARSE_ERROR;
-            reader->state = GRPC_JSON_STATE_VALUE_NULL_L2;
+          case State::GRPC_JSON_STATE_VALUE_NULL_L1:
+            if (c != 'l') return Status::GRPC_JSON_PARSE_ERROR;
+            state_ = State::GRPC_JSON_STATE_VALUE_NULL_L2;
             break;
 
-          case GRPC_JSON_STATE_VALUE_NULL_L2:
-            if (c != 'l') return GRPC_JSON_PARSE_ERROR;
-            json_reader_set_null(reader);
-            reader->state = GRPC_JSON_STATE_VALUE_END;
+          case State::GRPC_JSON_STATE_VALUE_NULL_L2:
+            if (c != 'l') return Status::GRPC_JSON_PARSE_ERROR;
+            SetNull();
+            state_ = State::GRPC_JSON_STATE_VALUE_END;
             break;
 
           /* All of the VALUE_END cases are handled in the specialized case
            * above. */
-          case GRPC_JSON_STATE_VALUE_END:
+          case State::GRPC_JSON_STATE_VALUE_END:
             switch (c) {
               case ',':
               case '}':
               case ']':
-                GPR_UNREACHABLE_CODE(return GRPC_JSON_INTERNAL_ERROR);
+                GPR_UNREACHABLE_CODE(return Status::GRPC_JSON_INTERNAL_ERROR);
                 break;
 
               default:
-                return GRPC_JSON_PARSE_ERROR;
+                return Status::GRPC_JSON_PARSE_ERROR;
             }
             break;
 
-          case GRPC_JSON_STATE_END:
-            return GRPC_JSON_PARSE_ERROR;
+          case State::GRPC_JSON_STATE_END:
+            return Status::GRPC_JSON_PARSE_ERROR;
         }
     }
   }
 
-  GPR_UNREACHABLE_CODE(return GRPC_JSON_INTERNAL_ERROR);
+  GPR_UNREACHABLE_CODE(return Status::GRPC_JSON_INTERNAL_ERROR);
+}
+
+grpc_error* JsonReader::Parse(absl::string_view input, Json* output) {
+  JsonReader reader(input);
+  Status status = reader.Run();
+  if (reader.truncated_errors_) {
+    reader.errors_.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "too many errors encountered during JSON parsing -- fix reported "
+        "errors and try again to see additional errors"));
+  }
+  if (status == Status::GRPC_JSON_INTERNAL_ERROR) {
+    reader.errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+        absl::StrCat("internal error in JSON parser at index ",
+                     reader.CurrentIndex())
+            .c_str()));
+  } else if (status == Status::GRPC_JSON_PARSE_ERROR) {
+    reader.errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+        absl::StrCat("JSON parse error at index ", reader.CurrentIndex())
+            .c_str()));
+  }
+  if (!reader.errors_.empty()) {
+    return GRPC_ERROR_CREATE_FROM_VECTOR("JSON parsing failed",
+                                         &reader.errors_);
+  }
+  *output = std::move(reader.root_value_);
+  return GRPC_ERROR_NONE;
+}
+
+}  // namespace
+
+Json Json::Parse(absl::string_view json_str, grpc_error** error) {
+  Json value;
+  *error = JsonReader::Parse(json_str, &value);
+  return value;
 }
+
+}  // namespace grpc_core