grpc 1.27.0 → 1.30.2

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

@@ -370,7 +370,7 @@ static void uv_resolve_callback(uv_getaddrinfo_t* req, int status,
                                tcp_error_create("getaddrinfo failed", status));
 }
 
-static grpc_error* uv_resolve(char* host, char* port,
+static grpc_error* uv_resolve(const char* host, const char* port,
                               grpc_resolved_addresses** result) {
   int status;
   uv_getaddrinfo_t req;
@@ -388,7 +388,8 @@ static grpc_error* uv_resolve(char* host, char* port,
   return tcp_error_create("getaddrinfo failed", status);
 }
 
-static void uv_resolve_async(grpc_custom_resolver* r, char* host, char* port) {
+static void uv_resolve_async(grpc_custom_resolver* r, const char* host,
+                             const char* port) {
   int status;
   uv_getaddrinfo_t* req =
       (uv_getaddrinfo_t*)gpr_malloc(sizeof(uv_getaddrinfo_t));

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

@@ -24,7 +24,7 @@
    weighted mean.  It is designed for batch operations where we do many adds
    before updating the average. */
 
-typedef struct {
+struct grpc_time_averaged_stats {
   /* The initial average value.  This is the reported average until the first
      grpc_time_averaged_stats_update_average call.  If a positive regress_weight
      is used, we also regress towards this value on each update. */
@@ -56,8 +56,7 @@ typedef struct {
   /* A time-decayed average of the (batch_total_value_ / batch_num_samples_),
      computed by decaying the samples_in_avg_ weight in the weighted average. */
   double aggregate_weighted_avg;
-} grpc_time_averaged_stats;
-
+};
 /* See the comments on the members above for an explanation of init_avg,
    regress_weight, and persistence_factor. */
 void grpc_time_averaged_stats_init(grpc_time_averaged_stats* stats,

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

@@ -56,7 +56,7 @@ grpc_core::TraceFlag grpc_timer_check_trace(false, "timer_check");
  * stats maintained in 'stats' and the relevant timers are then moved from the
  * 'list' to 'heap'.
  */
-typedef struct {
+struct timer_shard {
   gpr_mu mu;
   grpc_time_averaged_stats stats;
   /* All and only timers with deadlines < this will be in the heap. */
@@ -70,8 +70,7 @@ typedef struct {
   grpc_timer_heap heap;
   /* This holds timers whose deadline is >= queue_deadline_cap. */
   grpc_timer list;
-} timer_shard;
-
+};
 static size_t g_num_shards;
 
 /* Array of timer shards. Whenever a timer (grpc_timer *) is added, its address

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

@@ -0,0 +1,39 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef GRPC_CORE_LIB_IOMGR_TIMER_GENERIC_H
+#define GRPC_CORE_LIB_IOMGR_TIMER_GENERIC_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/support/time.h>
+#include "src/core/lib/iomgr/exec_ctx.h"
+
+struct grpc_timer {
+  gpr_atm deadline;
+  uint32_t heap_index; /* INVALID_HEAP_INDEX if not in heap */
+  bool pending;
+  struct grpc_timer* next;
+  struct grpc_timer* prev;
+  grpc_closure* closure;
+#ifndef NDEBUG
+  struct grpc_timer* hash_table_next;
+#endif
+};
+
+#endif /* GRPC_CORE_LIB_IOMGR_TIMER_GENERIC_H */

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

@@ -23,12 +23,11 @@
 
 #include "src/core/lib/iomgr/timer.h"
 
-typedef struct {
+struct grpc_timer_heap {
   grpc_timer** timers;
   uint32_t timer_count;
   uint32_t timer_capacity;
-} grpc_timer_heap;
-
+};
 /* return true if the new timer is the first timer in the heap */
 bool grpc_timer_heap_add(grpc_timer_heap* heap, grpc_timer* timer);
 

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

@@ -44,6 +44,8 @@
 #include <sys/types.h>
 #include <unistd.h>
 
+#include "absl/container/inlined_vector.h"
+
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -52,7 +54,6 @@
 #include <grpc/support/time.h>
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/inlined_vector.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/ev_posix.h"
@@ -147,11 +148,9 @@ GrpcUdpListener::GrpcUdpListener(grpc_udp_server* server, int fd,
       server_(server),
       orphan_notified_(false),
       already_shutdown_(false) {
-  char* addr_str;
   char* name;
-  grpc_sockaddr_to_string(&addr_str, addr, 1);
-  gpr_asprintf(&name, "udp-server-listener:%s", addr_str);
-  gpr_free(addr_str);
+  std::string addr_str = grpc_sockaddr_to_string(addr, true);
+  gpr_asprintf(&name, "udp-server-listener:%s", addr_str.c_str());
   emfd_ = grpc_fd_create(fd, name, true);
   memcpy(&addr_, addr, sizeof(grpc_resolved_address));
   GPR_ASSERT(emfd_);
@@ -177,7 +176,7 @@ struct grpc_udp_server {
   int shutdown;
 
   /* An array of listeners */
-  grpc_core::InlinedVector<GrpcUdpListener, 16> listeners;
+  absl::InlinedVector<GrpcUdpListener, 16> listeners;
 
   /* factory for use to create udp listeners */
   GrpcUdpHandlerFactory* handler_factory;
@@ -412,10 +411,8 @@ static int prepare_socket(grpc_socket_factory* socket_factory, int fd,
   }
 
   if (bind_socket(socket_factory, fd, addr) < 0) {
-    char* addr_str;
-    grpc_sockaddr_to_string(&addr_str, addr, 0);
-    gpr_log(GPR_ERROR, "bind addr=%s: %s", addr_str, strerror(errno));
-    gpr_free(addr_str);
+    std::string addr_str = grpc_sockaddr_to_string(addr, false);
+    gpr_log(GPR_ERROR, "bind addr=%s: %s", addr_str.c_str(), strerror(errno));
     goto error;
   }
 
@@ -582,10 +579,8 @@ int grpc_udp_server_add_port(grpc_udp_server* s,
             "Try to have multiple listeners on same port, but SO_REUSEPORT is "
             "not supported. Only create 1 listener.");
   }
-  char* addr_str;
-  grpc_sockaddr_to_string(&addr_str, addr, 1);
-  gpr_log(GPR_DEBUG, "add address: %s to server", addr_str);
-  gpr_free(addr_str);
+  std::string addr_str = grpc_sockaddr_to_string(addr, true);
+  gpr_log(GPR_DEBUG, "add address: %s to server", addr_str.c_str());
 
   int allocated_port1 = -1;
   int allocated_port2 = -1;

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

@@ -0,0 +1,155 @@
+/*
+ *
+ * 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 "src/core/lib/iomgr/work_serializer.h"
+
+namespace grpc_core {
+
+DebugOnlyTraceFlag grpc_work_serializer_trace(false, "work_serializer");
+
+struct CallbackWrapper {
+  CallbackWrapper(std::function<void()> cb, const grpc_core::DebugLocation& loc)
+      : callback(std::move(cb)), location(loc) {}
+
+  MultiProducerSingleConsumerQueue::Node mpscq_node;
+  const std::function<void()> callback;
+  const DebugLocation location;
+};
+
+class WorkSerializer::WorkSerializerImpl : public Orphanable {
+ public:
+  void Run(std::function<void()> callback,
+           const grpc_core::DebugLocation& location);
+
+  void Orphan() override;
+
+ private:
+  void DrainQueue();
+
+  // An initial size of 1 keeps track of whether the work serializer has been
+  // orphaned.
+  Atomic<size_t> size_{1};
+  MultiProducerSingleConsumerQueue queue_;
+};
+
+void WorkSerializer::WorkSerializerImpl::Run(
+    std::function<void()> callback, const grpc_core::DebugLocation& location) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
+    gpr_log(GPR_INFO, "WorkSerializer::Run() %p Scheduling callback [%s:%d]",
+            this, location.file(), location.line());
+  }
+  const size_t prev_size = size_.FetchAdd(1);
+  // The work serializer should not have been orphaned.
+  GPR_DEBUG_ASSERT(prev_size > 0);
+  if (prev_size == 1) {
+    // There is no other closure executing right now on this work serializer.
+    // Execute this closure immediately.
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
+      gpr_log(GPR_INFO, "  Executing immediately");
+    }
+    callback();
+    // Loan this thread to the work serializer thread and drain the queue.
+    DrainQueue();
+  } else {
+    CallbackWrapper* cb_wrapper =
+        new CallbackWrapper(std::move(callback), location);
+    // There already are closures executing on this work serializer. Simply add
+    // this closure to the queue.
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
+      gpr_log(GPR_INFO, "  Scheduling on queue : item %p", cb_wrapper);
+    }
+    queue_.Push(&cb_wrapper->mpscq_node);
+  }
+}
+
+void WorkSerializer::WorkSerializerImpl::Orphan() {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
+    gpr_log(GPR_INFO, "WorkSerializer::Orphan() %p", this);
+  }
+  size_t prev_size = size_.FetchSub(1);
+  if (prev_size == 1) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
+      gpr_log(GPR_INFO, "  Destroying");
+    }
+    delete this;
+  }
+}
+
+// The thread that calls this loans itself to the work serializer so as to
+// execute all the scheduled callback. This is called from within
+// WorkSerializer::Run() after executing a callback immediately, and hence size_
+// is at least 1.
+void WorkSerializer::WorkSerializerImpl::DrainQueue() {
+  while (true) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
+      gpr_log(GPR_INFO, "WorkSerializer::DrainQueue() %p", this);
+    }
+    size_t prev_size = size_.FetchSub(1);
+    GPR_DEBUG_ASSERT(prev_size >= 1);
+    // It is possible that while draining the queue, one of the callbacks ended
+    // up orphaning the work serializer. In that case, delete the object.
+    if (prev_size == 1) {
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
+        gpr_log(GPR_INFO, "  Queue Drained. Destroying");
+      }
+      delete this;
+      return;
+    }
+    if (prev_size == 2) {
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
+        gpr_log(GPR_INFO, "  Queue Drained");
+      }
+      return;
+    }
+    // There is at least one callback on the queue. Pop the callback from the
+    // queue and execute it.
+    CallbackWrapper* cb_wrapper = nullptr;
+    bool empty_unused;
+    while ((cb_wrapper = reinterpret_cast<CallbackWrapper*>(
+                queue_.PopAndCheckEnd(&empty_unused))) == nullptr) {
+      // This can happen either due to a race condition within the mpscq
+      // implementation or because of a race with Run()
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
+        gpr_log(GPR_INFO, "  Queue returned nullptr, trying again");
+      }
+    }
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
+      gpr_log(GPR_INFO, "  Running item %p : callback scheduled at [%s:%d]",
+              cb_wrapper, cb_wrapper->location.file(),
+              cb_wrapper->location.line());
+    }
+    cb_wrapper->callback();
+    delete cb_wrapper;
+  }
+}
+
+// WorkSerializer
+
+WorkSerializer::WorkSerializer()
+    : impl_(MakeOrphanable<WorkSerializerImpl>()) {}
+
+WorkSerializer::~WorkSerializer() {}
+
+void WorkSerializer::Run(std::function<void()> callback,
+                         const grpc_core::DebugLocation& location) {
+  impl_->Run(std::move(callback), location);
+}
+
+}  // namespace grpc_core

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,220 @@
 
 #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 "absl/strings/string_view.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);
+#include "src/core/lib/iomgr/error.h"
 
-/* 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);
+namespace grpc_core {
+
+// 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(absl::string_view 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 */