grpc 1.27.0 → 1.28.0

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

@@ -0,0 +1,65 @@
+/*
+ *
+ * Copyright 2019 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.
+ *
+ */
+
+#include <grpc/support/port_platform.h>
+
+#include <functional>
+
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/atomic.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/mpscq.h"
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+
+#ifndef GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
+#define GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
+
+namespace grpc_core {
+
+// WorkSerializer is a mechanism to schedule callbacks in a synchronized manner.
+// All callbacks scheduled on a WorkSerializer instance will be executed
+// serially in a borrowed thread. The API provides a FIFO guarantee to the
+// execution of callbacks scheduled on the thread.
+// When a thread calls Run() with a callback, the thread is considered borrowed.
+// The callback might run inline, or it might run asynchronously in a different
+// thread that is already inside of Run(). If the callback runs directly inline,
+// other callbacks from other threads might also be executed before Run()
+// returns. Since an arbitrary set of callbacks might be executed when Run() is
+// called, generally no locks should be held while calling Run().
+class WorkSerializer {
+ public:
+  WorkSerializer();
+
+  ~WorkSerializer();
+
+  // TODO(yashkt): Replace grpc_core::DebugLocation with absl::SourceLocation
+  // once we can start using it directly.
+  void Run(std::function<void()> callback,
+           const grpc_core::DebugLocation& location);
+
+ private:
+  class WorkSerializerImpl;
+
+  OrphanablePtr<WorkSerializerImpl> impl_;
+};
+
+} /* namespace grpc_core */
+
+#endif /* GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H */

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

@@ -21,89 +21,219 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdbool.h>
 #include <stdlib.h>
 
-/* The various json types. */
-typedef enum {
-  GRPC_JSON_OBJECT,
-  GRPC_JSON_ARRAY,
-  GRPC_JSON_STRING,
-  GRPC_JSON_NUMBER,
-  GRPC_JSON_TRUE,
-  GRPC_JSON_FALSE,
-  GRPC_JSON_NULL,
-  GRPC_JSON_TOP_LEVEL
-} grpc_json_type;
-
-/* A tree-like structure to hold json values. The key and value pointers
- * are not owned by it.
- */
-typedef struct grpc_json {
-  struct grpc_json* next;
-  struct grpc_json* prev;
-  struct grpc_json* child;
-  struct grpc_json* parent;
-
-  grpc_json_type type;
-  const char* key;
-  const char* value;
-
-  /* if set, destructor will free value */
-  bool owns_value;
-} grpc_json;
-
-/* The next two functions are going to parse the input string, and
- * modify it in the process, in order to use its space to store
- * all of the keys and values for the returned object tree.
- *
- * They assume UTF-8 input stream, and will output UTF-8 encoded
- * strings in the tree. The input stream's UTF-8 isn't validated,
- * as in, what you input is what you get as an output.
- *
- * All the keys and values in the grpc_json objects will be strings
- * pointing at your input buffer.
- *
- * Delete the allocated tree afterward using grpc_json_destroy().
- */
-grpc_json* grpc_json_parse_string_with_len(char* input, size_t size);
-grpc_json* grpc_json_parse_string(char* input);
+#include <map>
+#include <string>
+#include <vector>
 
-/* This function will create a new string using gpr_realloc, and will
- * deserialize the grpc_json tree into it. It'll be zero-terminated,
- * but will be allocated in chunks of 256 bytes.
- *
- * The indent parameter controls the way the output is formatted.
- * If indent is 0, then newlines will be suppressed as well, and the
- * output will be condensed at its maximum.
- */
-char* grpc_json_dump_to_string(const grpc_json* json, int indent);
+#include "src/core/lib/gprpp/string_view.h"
+#include "src/core/lib/iomgr/error.h"
 
-/* Use these to create or delete a grpc_json object.
- * Deletion is recursive. We will not attempt to free any of the strings
- * in any of the objects of that tree, unless the boolean, owns_value,
- * is true.
- */
-grpc_json* grpc_json_create(grpc_json_type type);
-void grpc_json_destroy(grpc_json* json);
+namespace grpc_core {
 
-/* Links the child json object into the parent's json tree. If the parent
- * already has children, then passing in the most recently added child as the
- * sibling parameter is an optimization. For if sibling is NULL, this function
- * will manually traverse the tree in order to find the right most sibling.
- */
-grpc_json* grpc_json_link_child(grpc_json* parent, grpc_json* child,
-                                grpc_json* sibling);
-
-/* Creates a child json object into the parent's json tree then links it in
- * as described above. */
-grpc_json* grpc_json_create_child(grpc_json* sibling, grpc_json* parent,
-                                  const char* key, const char* value,
-                                  grpc_json_type type, bool owns_value);
-
-/* Creates a child json string object from the integer num, then links the
-   json object into the parent's json tree */
-grpc_json* grpc_json_add_number_string_child(grpc_json* parent, grpc_json* it,
-                                             const char* name, int64_t num);
+// A JSON value, which can be any one of object, array, string,
+// number, true, false, or null.
+class Json {
+ public:
+  // TODO(roth): Currently, numbers are stored internally as strings,
+  // which makes the API a bit cumbersome to use. When we have time,
+  // 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
+  };
+
+  using Object = std::map<std::string, Json>;
+  using Array = std::vector<Json>;
+
+  // Parses JSON string from json_str.  On error, sets *error.
+  static Json Parse(StringView json_str, grpc_error** error);
+
+  Json() = default;
+
+  // Copyable.
+  Json(const Json& other) { CopyFrom(other); }
+  Json& operator=(const Json& other) {
+    CopyFrom(other);
+    return *this;
+  }
+
+  // Moveable.
+  Json(Json&& other) { MoveFrom(std::move(other)); }
+  Json& operator=(Json&& other) {
+    MoveFrom(std::move(other));
+    return *this;
+  }
+
+  // Construct from copying a string.
+  // If is_number is true, the type will be NUMBER instead of STRING.
+  Json(const std::string& string, bool is_number = false)
+      : type_(is_number ? Type::NUMBER : Type::STRING), string_value_(string) {}
+  Json& operator=(const std::string& string) {
+    type_ = Type::STRING;
+    string_value_ = string;
+    return *this;
+  }
+
+  // Same thing for C-style strings, both const and mutable.
+  Json(const char* string, bool is_number = false)
+      : Json(std::string(string), is_number) {}
+  Json& operator=(const char* string) {
+    *this = std::string(string);
+    return *this;
+  }
+  Json(char* string, bool is_number = false)
+      : Json(std::string(string), is_number) {}
+  Json& operator=(char* string) {
+    *this = std::string(string);
+    return *this;
+  }
+
+  // Construct by moving a string.
+  Json(std::string&& string)
+      : type_(Type::STRING), string_value_(std::move(string)) {}
+  Json& operator=(std::string&& string) {
+    type_ = Type::STRING;
+    string_value_ = std::move(string);
+    return *this;
+  }
+
+  // Construct from bool.
+  Json(bool b) : type_(b ? Type::JSON_TRUE : Type::JSON_FALSE) {}
+  Json& operator=(bool b) {
+    type_ = b ? Type::JSON_TRUE : Type::JSON_FALSE;
+    return *this;
+  }
+
+  // Construct from any numeric type.
+  template <typename NumericType>
+  Json(NumericType number)
+      : type_(Type::NUMBER), string_value_(std::to_string(number)) {}
+  template <typename NumericType>
+  Json& operator=(NumericType number) {
+    type_ = Type::NUMBER;
+    string_value_ = std::to_string(number);
+    return *this;
+  }
+
+  // Construct by copying object.
+  Json(const Object& object) : type_(Type::OBJECT), object_value_(object) {}
+  Json& operator=(const Object& object) {
+    type_ = Type::OBJECT;
+    object_value_ = object;
+    return *this;
+  }
+
+  // Construct by moving object.
+  Json(Object&& object)
+      : type_(Type::OBJECT), object_value_(std::move(object)) {}
+  Json& operator=(Object&& object) {
+    type_ = Type::OBJECT;
+    object_value_ = std::move(object);
+    return *this;
+  }
+
+  // Construct by copying array.
+  Json(const Array& array) : type_(Type::ARRAY), array_value_(array) {}
+  Json& operator=(const Array& array) {
+    type_ = Type::ARRAY;
+    array_value_ = array;
+    return *this;
+  }
+
+  // Construct by moving array.
+  Json(Array&& array) : type_(Type::ARRAY), array_value_(std::move(array)) {}
+  Json& operator=(Array&& array) {
+    type_ = Type::ARRAY;
+    array_value_ = std::move(array);
+    return *this;
+  }
+
+  // Dumps JSON from value to string form.
+  std::string Dump(int indent = 0) const;
+
+  // 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;
+  }
+
+  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;
+    }
+  }
+
+  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;
+    }
+  }
+
+  Type type_ = Type::JSON_NULL;
+  std::string string_value_;
+  Object object_value_;
+  Array array_value_;
+};
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_JSON_JSON_H */

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

@@ -21,246 +21,264 @@
 #include <string.h>
 
 #include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
 
 #include "src/core/lib/json/json.h"
 
-typedef enum {
-  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
-} grpc_json_reader_state;
-
-enum {
+#define GRPC_JSON_MAX_DEPTH 255
+#define GRPC_JSON_MAX_ERRORS 16
+
+namespace grpc_core {
+
+namespace {
+
+class JsonReader {
+ public:
+  static grpc_error* Parse(StringView 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.
    */
-  GRPC_JSON_READ_CHAR_EOF = 0x7ffffff0,
-  GRPC_JSON_READ_CHAR_EAGAIN,
-  GRPC_JSON_READ_CHAR_ERROR
+  static constexpr uint32_t GRPC_JSON_READ_CHAR_EOF = 0x7ffffff0;
+
+  explicit JsonReader(StringView 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_;
 };
 
-typedef struct grpc_json_reader {
-  /* That structure is fully private, and initialized by grpc_json_reader_init.
-   * The definition is public so you can put it on your stack.
-   */
-
-  int depth;
-  int in_object;
-  int in_array;
-  int escaped_string_was_key;
-  int container_just_begun;
-  uint16_t unicode_char, unicode_high_surrogate;
-  grpc_json_reader_state state;
-
-  grpc_json* top;
-  grpc_json* current_container;
-  grpc_json* current_value;
-  uint8_t* input;
-  uint8_t* key;
-  uint8_t* string;
-  uint8_t* string_ptr;
-  size_t remaining_input;
-} grpc_json_reader;
-
-/* The return type of the parser. */
-typedef enum {
-  GRPC_JSON_DONE,          /* The parser finished successfully. */
-  GRPC_JSON_EAGAIN,        /* The parser yields to get more data. */
-  GRPC_JSON_READ_ERROR,    /* The parser passes through a read error. */
-  GRPC_JSON_PARSE_ERROR,   /* The parser found an error in the json stream. */
-  GRPC_JSON_INTERNAL_ERROR /* The parser got an internal error. */
-} grpc_json_reader_status;
-
-static void json_reader_string_clear(grpc_json_reader* reader) {
-  if (reader->string) {
-    GPR_ASSERT(reader->string_ptr < reader->input);
-    *reader->string_ptr++ = 0;
-  }
-  reader->string = reader->string_ptr;
-}
-
-static void json_reader_string_add_char(grpc_json_reader* reader, uint32_t c) {
-  GPR_ASSERT(reader->string_ptr < reader->input);
-  GPR_ASSERT(c <= 0xff);
-  *reader->string_ptr++ = static_cast<uint8_t>(c);
+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 c) {
+void JsonReader::StringAddUtf32(uint32_t c) {
   if (c <= 0x7f) {
-    json_reader_string_add_char(reader, c);
+    StringAddChar(c);
   } else if (c <= 0x7ff) {
     uint32_t b1 = 0xc0 | ((c >> 6) & 0x1f);
     uint32_t b2 = 0x80 | (c & 0x3f);
-    json_reader_string_add_char(reader, b1);
-    json_reader_string_add_char(reader, b2);
+    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);
-    json_reader_string_add_char(reader, b1);
-    json_reader_string_add_char(reader, b2);
-    json_reader_string_add_char(reader, b3);
+    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);
-    json_reader_string_add_char(reader, b1);
-    json_reader_string_add_char(reader, b2);
-    json_reader_string_add_char(reader, b3);
-    json_reader_string_add_char(reader, b4);
+    StringAddChar(b1);
+    StringAddChar(b2);
+    StringAddChar(b3);
+    StringAddChar(b4);
   }
 }
 
-static uint32_t grpc_json_reader_read_char(grpc_json_reader* reader) {
-  if (reader->remaining_input == 0) return GRPC_JSON_READ_CHAR_EOF;
-  uint32_t r = *reader->input++;
-  reader->remaining_input--;
+uint32_t JsonReader::ReadChar() {
+  if (remaining_input_ == 0) return GRPC_JSON_READ_CHAR_EOF;
+  const uint32_t r = *input_++;
+  --remaining_input_;
   if (r == 0) {
-    reader->remaining_input = 0;
+    remaining_input_ = 0;
     return GRPC_JSON_READ_CHAR_EOF;
   }
   return r;
 }
 
-/* Helper function to create a new grpc_json object and link it into
- * our tree-in-progress inside our opaque structure.
- */
-static grpc_json* json_create_and_link(grpc_json_reader* reader,
-                                       grpc_json_type type) {
-  grpc_json* json = grpc_json_create(type);
-  json->parent = reader->current_container;
-  json->prev = reader->current_value;
-  reader->current_value = json;
-  if (json->prev) {
-    json->prev->next = json;
-  }
-  if (json->parent) {
-    if (!json->parent->child) {
-      json->parent->child = json;
-    }
-    if (json->parent->type == GRPC_JSON_OBJECT) {
-      json->key = reinterpret_cast<char*>(reader->key);
+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 {
+          char* msg;
+          gpr_asprintf(&msg, "duplicate key \"%s\" at index %" PRIuPTR,
+                       key_.c_str(), CurrentIndex());
+          errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg));
+          gpr_free(msg);
+        }
+      }
+      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();
     }
   }
-  if (!reader->top) {
-    reader->top = json;
-  }
-  return json;
+  return value;
 }
 
-static void json_reader_container_begins(grpc_json_reader* reader,
-                                         grpc_json_type type) {
-  GPR_ASSERT(type == GRPC_JSON_ARRAY || type == GRPC_JSON_OBJECT);
-  grpc_json* container = json_create_and_link(reader, type);
-  reader->current_container = container;
-  reader->current_value = nullptr;
-}
-
-static grpc_json_type grpc_json_reader_container_ends(
-    grpc_json_reader* reader) {
-  grpc_json_type container_type = GRPC_JSON_TOP_LEVEL;
-  GPR_ASSERT(reader->current_container);
-  reader->current_value = reader->current_container;
-  reader->current_container = reader->current_container->parent;
-  if (reader->current_container) {
-    container_type = reader->current_container->type;
+bool JsonReader::StartContainer(Json::Type type) {
+  if (stack_.size() == GRPC_JSON_MAX_DEPTH) {
+    if (errors_.size() == GRPC_JSON_MAX_ERRORS) {
+      truncated_errors_ = true;
+    } else {
+      char* msg;
+      gpr_asprintf(&msg, "exceeded max stack depth (%d) at index %" PRIuPTR,
+                   GRPC_JSON_MAX_DEPTH, CurrentIndex());
+      errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg));
+      gpr_free(msg);
+    }
+    return false;
   }
-  return container_type;
+  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->key = reader->string;
+void JsonReader::EndContainer() {
+  GPR_ASSERT(!stack_.empty());
+  stack_.pop_back();
 }
 
-static void json_reader_set_string(grpc_json_reader* reader) {
-  grpc_json* json = json_create_and_link(reader, GRPC_JSON_STRING);
-  json->value = reinterpret_cast<char*>(reader->string);
+void JsonReader::SetKey() {
+  key_ = std::move(string_);
+  string_.clear();
 }
 
-static int json_reader_set_number(grpc_json_reader* reader) {
-  grpc_json* json = json_create_and_link(reader, GRPC_JSON_NUMBER);
-  json->value = reinterpret_cast<char*>(reader->string);
-  return 1;
+void JsonReader::SetString() {
+  Json* value = CreateAndLinkValue();
+  *value = std::move(string_);
+  string_.clear();
 }
 
-static void json_reader_set_true(grpc_json_reader* reader) {
-  json_create_and_link(reader, GRPC_JSON_TRUE);
+bool JsonReader::SetNumber() {
+  Json* value = CreateAndLinkValue();
+  *value = Json(std::move(string_), /*is_number=*/true);
+  string_.clear();
+  return true;
 }
 
-static void json_reader_set_false(grpc_json_reader* reader) {
-  json_create_and_link(reader, GRPC_JSON_FALSE);
+void JsonReader::SetTrue() {
+  Json* value = CreateAndLinkValue();
+  *value = true;
+  string_.clear();
 }
 
-static void json_reader_set_null(grpc_json_reader* reader) {
-  json_create_and_link(reader, GRPC_JSON_NULL);
+void JsonReader::SetFalse() {
+  Json* value = CreateAndLinkValue();
+  *value = false;
+  string_.clear();
 }
 
-static int 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)));
+void JsonReader::SetNull() { CreateAndLinkValue(); }
+
+bool JsonReader::IsComplete() {
+  return (stack_.empty() && (state_ == State::GRPC_JSON_STATE_END ||
+                             state_ == State::GRPC_JSON_STATE_VALUE_END));
 }
 
 /* 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_EAGAIN if the read_char function returned again. Call the
- *      parser again as needed. It is okay to call the parser in polling mode,
- *      although a bit dull.
- *    . GRPC_JSON_READ_ERROR if the read_char function returned an error. The
- *      state isn't broken however, and the function can be called again if the
- *      error has been corrected. But please use the EAGAIN feature instead for
- *      consistency.
  *    . GRPC_JSON_PARSE_ERROR if the input was somehow invalid.
  *    . GRPC_JSON_INTERNAL_ERROR if the parser somehow ended into an invalid
  *      internal state.
  */
-static grpc_json_reader_status grpc_json_reader_run(grpc_json_reader* reader) {
-  uint32_t c, success;
+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 (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;
 
@@ -269,34 +287,33 @@ static 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;
 
@@ -304,182 +321,171 @@ static 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 == '}') &&
-                  (reader->state == GRPC_JSON_STATE_OBJECT_KEY_BEGIN) &&
-                  !reader->container_just_begun) {
-                return 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->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 == ']' && stack_.back()->type() != Json::Type::ARRAY) {
+                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);
+              if (c == ']' && state_ == State::GRPC_JSON_STATE_VALUE_BEGIN &&
+                  !container_just_begun_) {
+                return Status::GRPC_JSON_PARSE_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':
@@ -492,73 +498,71 @@ static 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')) {
@@ -566,62 +570,60 @@ static 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':
@@ -636,18 +638,18 @@ static 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':
@@ -662,21 +664,21 @@ static 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':
@@ -688,15 +690,15 @@ static 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':
@@ -710,15 +712,15 @@ static 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':
@@ -732,110 +734,122 @@ static 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);
 }
 
-/* And finally, let's define our public API. */
-grpc_json* grpc_json_parse_string_with_len(char* input, size_t size) {
-  if (input == nullptr) return nullptr;
-  // Initialize reader.
-  grpc_json_reader reader;
-  memset(&reader, 0, sizeof(reader));
-  reader.string_ptr = reader.input = reinterpret_cast<uint8_t*>(input);
-  reader.remaining_input = size;
-  json_reader_string_clear(&reader);
-  reader.state = GRPC_JSON_STATE_VALUE_BEGIN;
-  // Perform read.
-  grpc_json_reader_status status = grpc_json_reader_run(&reader);
-  // Process results.
-  grpc_json* json = reader.top;
-  if ((status != GRPC_JSON_DONE) && json != nullptr) {
-    grpc_json_destroy(json);
-    json = nullptr;
+grpc_error* JsonReader::Parse(StringView 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"));
   }
-  return json;
+  if (status == Status::GRPC_JSON_INTERNAL_ERROR) {
+    char* msg;
+    gpr_asprintf(&msg, "internal error in JSON parser at index %" PRIuPTR,
+                 reader.CurrentIndex());
+    reader.errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg));
+    gpr_free(msg);
+  } else if (status == Status::GRPC_JSON_PARSE_ERROR) {
+    char* msg;
+    gpr_asprintf(&msg, "JSON parse error at index %" PRIuPTR,
+                 reader.CurrentIndex());
+    reader.errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg));
+    gpr_free(msg);
+  }
+  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;
 }
 
-#define UNBOUND_JSON_STRING_LENGTH 0x7fffffff
+}  // namespace
 
-grpc_json* grpc_json_parse_string(char* input) {
-  return grpc_json_parse_string_with_len(input, UNBOUND_JSON_STRING_LENGTH);
+Json Json::Parse(StringView json_str, grpc_error** error) {
+  Json value;
+  *error = JsonReader::Parse(json_str, &value);
+  return value;
 }
+
+}  // namespace grpc_core