grpc 1.32.0 → 1.35.0

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

@@ -181,8 +181,9 @@ class TcpZerocopySendCtx {
   static constexpr int kDefaultMaxSends = 4;
   static constexpr size_t kDefaultSendBytesThreshold = 16 * 1024;  // 16KB
 
-  TcpZerocopySendCtx(int max_sends = kDefaultMaxSends,
-                     size_t send_bytes_threshold = kDefaultSendBytesThreshold)
+  explicit TcpZerocopySendCtx(
+      int max_sends = kDefaultMaxSends,
+      size_t send_bytes_threshold = kDefaultSendBytesThreshold)
       : max_sends_(max_sends),
         free_send_records_size_(max_sends),
         threshold_bytes_(send_bytes_threshold) {
@@ -465,7 +466,8 @@ static void run_poller(void* bp, grpc_error* /*error_ignored*/) {
   if (gpr_atm_no_barrier_load(&g_uncovered_notifications_pending) == 1 &&
       gpr_atm_full_cas(&g_uncovered_notifications_pending, 1, 0)) {
     gpr_mu_lock(p->pollset_mu);
-    bool cas_ok = gpr_atm_full_cas(&g_backup_poller, (gpr_atm)p, 0);
+    bool cas_ok =
+        gpr_atm_full_cas(&g_backup_poller, reinterpret_cast<gpr_atm>(p), 0);
     if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
       gpr_log(GPR_INFO, "BACKUP_POLLER:%p done cas_ok=%d", p, cas_ok);
     }
@@ -487,7 +489,8 @@ static void run_poller(void* bp, grpc_error* /*error_ignored*/) {
 }
 
 static void drop_uncovered(grpc_tcp* /*tcp*/) {
-  backup_poller* p = (backup_poller*)gpr_atm_acq_load(&g_backup_poller);
+  backup_poller* p =
+      reinterpret_cast<backup_poller*>(gpr_atm_acq_load(&g_backup_poller));
   gpr_atm old_count =
       gpr_atm_full_fetch_add(&g_uncovered_notifications_pending, -1);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
@@ -526,8 +529,8 @@ static void cover_self(grpc_tcp* tcp) {
         GRPC_ERROR_NONE, grpc_core::ExecutorType::DEFAULT,
         grpc_core::ExecutorJobType::LONG);
   } else {
-    while ((p = (backup_poller*)gpr_atm_acq_load(&g_backup_poller)) ==
-           nullptr) {
+    while ((p = reinterpret_cast<backup_poller*>(
+                gpr_atm_acq_load(&g_backup_poller))) == nullptr) {
       // spin waiting for backup poller
     }
   }
@@ -1689,7 +1692,7 @@ static const grpc_endpoint_vtable vtable = {tcp_read,
                                             tcp_get_fd,
                                             tcp_can_track_err};
 
-#define MAX_CHUNK_SIZE 32 * 1024 * 1024
+#define MAX_CHUNK_SIZE (32 * 1024 * 1024)
 
 grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd,
                                const grpc_channel_args* channel_args,
@@ -1798,7 +1801,8 @@ grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd,
 #endif
   }
   /* paired with unref in grpc_tcp_destroy */
-  new (&tcp->refcount) grpc_core::RefCount(1, &grpc_tcp_trace);
+  new (&tcp->refcount) grpc_core::RefCount(
+      1, GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace) ? "tcp" : nullptr);
   gpr_atm_no_barrier_store(&tcp->shutdown_count, 0);
   tcp->em_fd = em_fd;
   grpc_slice_buffer_init(&tcp->last_read_buffer);

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

@@ -83,7 +83,8 @@ struct grpc_tcp_server {
 static grpc_error* tcp_server_create(grpc_closure* shutdown_complete,
                                      const grpc_channel_args* args,
                                      grpc_tcp_server** server) {
-  grpc_tcp_server* s = (grpc_tcp_server*)gpr_malloc(sizeof(grpc_tcp_server));
+  grpc_tcp_server* s =
+      static_cast<grpc_tcp_server*>(gpr_malloc(sizeof(grpc_tcp_server)));
   // Let the implementation decide if so_reuseport can be enabled or not.
   s->so_reuseport = true;
   s->resource_quota = grpc_resource_quota_create(nullptr);
@@ -95,7 +96,7 @@ static grpc_error* tcp_server_create(grpc_closure* shutdown_complete,
       if (args->args[i].type == GRPC_ARG_POINTER) {
         grpc_resource_quota_unref_internal(s->resource_quota);
         s->resource_quota = grpc_resource_quota_ref_internal(
-            (grpc_resource_quota*)args->args[i].value.pointer.p);
+            static_cast<grpc_resource_quota*>(args->args[i].value.pointer.p));
       } else {
         grpc_resource_quota_unref_internal(s->resource_quota);
         gpr_free(s);
@@ -163,12 +164,12 @@ static void custom_close_callback(grpc_custom_socket* socket) {
   }
 }
 
-void grpc_custom_close_server_callback(grpc_tcp_listener* sp) {
-  if (sp) {
+void grpc_custom_close_server_callback(grpc_tcp_listener* listener) {
+  if (listener) {
     grpc_core::ExecCtx exec_ctx;
-    sp->server->open_ports--;
-    if (sp->server->open_ports == 0 && sp->server->shutdown) {
-      finish_shutdown(sp->server);
+    listener->server->open_ports--;
+    if (listener->server->open_ports == 0 && listener->server->shutdown) {
+      finish_shutdown(listener->server);
     }
   }
 }
@@ -213,7 +214,7 @@ static void tcp_server_unref(grpc_tcp_server* s) {
 
 static void finish_accept(grpc_tcp_listener* sp, grpc_custom_socket* socket) {
   grpc_tcp_server_acceptor* acceptor =
-      (grpc_tcp_server_acceptor*)gpr_malloc(sizeof(*acceptor));
+      static_cast<grpc_tcp_server_acceptor*>(gpr_malloc(sizeof(*acceptor)));
   grpc_endpoint* ep = nullptr;
   grpc_resolved_address peer_name;
   std::string peer_name_string;
@@ -222,7 +223,8 @@ static void finish_accept(grpc_tcp_listener* sp, grpc_custom_socket* socket) {
   memset(&peer_name, 0, sizeof(grpc_resolved_address));
   peer_name.len = GRPC_MAX_SOCKADDR_SIZE;
   err = grpc_custom_socket_vtable->getpeername(
-      socket, (grpc_sockaddr*)&peer_name.addr, (int*)&peer_name.len);
+      socket, reinterpret_cast<grpc_sockaddr*>(&peer_name.addr),
+      reinterpret_cast<int*>(&peer_name.len));
   if (err == GRPC_ERROR_NONE) {
     peer_name_string = grpc_sockaddr_to_uri(&peer_name);
   } else {
@@ -262,8 +264,8 @@ static void custom_accept_callback(grpc_custom_socket* socket,
   }
   finish_accept(sp, client);
   if (!sp->closed) {
-    grpc_custom_socket* new_socket =
-        (grpc_custom_socket*)gpr_malloc(sizeof(grpc_custom_socket));
+    grpc_custom_socket* new_socket = static_cast<grpc_custom_socket*>(
+        gpr_malloc(sizeof(grpc_custom_socket)));
     new_socket->endpoint = nullptr;
     new_socket->listener = nullptr;
     new_socket->connector = nullptr;
@@ -290,8 +292,9 @@ static grpc_error* add_socket_to_server(grpc_tcp_server* s,
     flags |= GRPC_CUSTOM_SOCKET_OPT_SO_REUSEPORT;
   }
 
-  error = grpc_custom_socket_vtable->bind(socket, (grpc_sockaddr*)addr->addr,
-                                          addr->len, flags);
+  error = grpc_custom_socket_vtable->bind(
+      socket, reinterpret_cast<grpc_sockaddr*>(const_cast<char*>(addr->addr)),
+      addr->len, flags);
   if (error != GRPC_ERROR_NONE) {
     return error;
   }
@@ -303,7 +306,8 @@ static grpc_error* add_socket_to_server(grpc_tcp_server* s,
 
   sockname_temp.len = GRPC_MAX_SOCKADDR_SIZE;
   error = grpc_custom_socket_vtable->getsockname(
-      socket, (grpc_sockaddr*)&sockname_temp.addr, (int*)&sockname_temp.len);
+      socket, reinterpret_cast<grpc_sockaddr*>(&sockname_temp.addr),
+      reinterpret_cast<int*>(&sockname_temp.len));
   if (error != GRPC_ERROR_NONE) {
     return error;
   }
@@ -312,7 +316,7 @@ static grpc_error* add_socket_to_server(grpc_tcp_server* s,
 
   GPR_ASSERT(port >= 0);
   GPR_ASSERT(!s->on_accept_cb && "must add ports before starting server");
-  sp = (grpc_tcp_listener*)gpr_zalloc(sizeof(grpc_tcp_listener));
+  sp = static_cast<grpc_tcp_listener*>(gpr_zalloc(sizeof(grpc_tcp_listener)));
   sp->next = nullptr;
   if (s->head == nullptr) {
     s->head = sp;
@@ -358,12 +362,13 @@ static grpc_error* tcp_server_add_port(grpc_tcp_server* s,
       socket = sp->socket;
       sockname_temp.len = GRPC_MAX_SOCKADDR_SIZE;
       if (nullptr == grpc_custom_socket_vtable->getsockname(
-                         socket, (grpc_sockaddr*)&sockname_temp.addr,
-                         (int*)&sockname_temp.len)) {
+                         socket,
+                         reinterpret_cast<grpc_sockaddr*>(&sockname_temp.addr),
+                         reinterpret_cast<int*>(&sockname_temp.len))) {
         *port = grpc_sockaddr_get_port(&sockname_temp);
         if (*port > 0) {
-          allocated_addr =
-              (grpc_resolved_address*)gpr_malloc(sizeof(grpc_resolved_address));
+          allocated_addr = static_cast<grpc_resolved_address*>(
+              gpr_malloc(sizeof(grpc_resolved_address)));
           memcpy(allocated_addr, addr, sizeof(grpc_resolved_address));
           grpc_sockaddr_set_port(allocated_addr, *port);
           addr = allocated_addr;
@@ -391,7 +396,8 @@ static grpc_error* tcp_server_add_port(grpc_tcp_server* s,
   }
 
   family = grpc_sockaddr_get_family(addr);
-  socket = (grpc_custom_socket*)gpr_malloc(sizeof(grpc_custom_socket));
+  socket =
+      static_cast<grpc_custom_socket*>(gpr_malloc(sizeof(grpc_custom_socket)));
   socket->refs = 1;
   socket->endpoint = nullptr;
   socket->listener = nullptr;
@@ -430,8 +436,8 @@ static void tcp_server_start(grpc_tcp_server* server,
   server->on_accept_cb = on_accept_cb;
   server->on_accept_cb_arg = cb_arg;
   for (sp = server->head; sp; sp = sp->next) {
-    grpc_custom_socket* new_socket =
-        (grpc_custom_socket*)gpr_malloc(sizeof(grpc_custom_socket));
+    grpc_custom_socket* new_socket = static_cast<grpc_custom_socket*>(
+        gpr_malloc(sizeof(grpc_custom_socket)));
     new_socket->endpoint = nullptr;
     new_socket->listener = nullptr;
     new_socket->connector = nullptr;

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

@@ -36,7 +36,7 @@ void grpc_custom_timer_callback(grpc_custom_timer* t, grpc_error* /*error*/) {
   grpc_core::ExecCtx exec_ctx;
   grpc_timer* timer = t->original;
   GPR_ASSERT(timer->pending);
-  timer->pending = 0;
+  timer->pending = false;
   grpc_core::ExecCtx::Run(DEBUG_LOCATION, timer->closure, GRPC_ERROR_NONE);
   custom_timer_impl->stop(t);
   gpr_free(t);
@@ -57,18 +57,18 @@ static void timer_init(grpc_timer* timer, grpc_millis deadline,
   timer->pending = true;
   timer->closure = closure;
   grpc_custom_timer* timer_wrapper =
-      (grpc_custom_timer*)gpr_malloc(sizeof(grpc_custom_timer));
+      static_cast<grpc_custom_timer*>(gpr_malloc(sizeof(grpc_custom_timer)));
   timer_wrapper->timeout_ms = timeout;
-  timer->custom_timer = (void*)timer_wrapper;
+  timer->custom_timer = timer_wrapper;
   timer_wrapper->original = timer;
   custom_timer_impl->start(timer_wrapper);
 }
 
 static void timer_cancel(grpc_timer* timer) {
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
-  grpc_custom_timer* tw = (grpc_custom_timer*)timer->custom_timer;
+  grpc_custom_timer* tw = static_cast<grpc_custom_timer*>(timer->custom_timer);
   if (timer->pending) {
-    timer->pending = 0;
+    timer->pending = false;
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, timer->closure,
                             GRPC_ERROR_CANCELLED);
     custom_timer_impl->stop(tw);

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

@@ -432,7 +432,7 @@ static void timer_init(grpc_timer* timer, grpc_millis deadline,
       note_deadline_change(shard);
       if (shard->shard_queue_index == 0 && deadline < old_min_deadline) {
 #if GPR_ARCH_64
-        // TODO: sreek - Using c-style cast here. static_cast<> gives an error
+        // TODO(sreek): Using c-style cast here. static_cast<> gives an error
         // (on mac platforms complaining that gpr_atm* is (long *) while
         // (&g_shared_mutables.min_timer) is a (long long *). The cast should be
         // safe since we know that both are pointer types and 64-bit wide.
@@ -586,7 +586,7 @@ static grpc_timer_check_result run_some_expired_timers(grpc_millis now,
   grpc_timer_check_result result = GRPC_TIMERS_NOT_CHECKED;
 
 #if GPR_ARCH_64
-  // TODO: sreek - Using c-style cast here. static_cast<> gives an error (on
+  // TODO(sreek): Using c-style cast here. static_cast<> gives an error (on
   // mac platforms complaining that gpr_atm* is (long *) while
   // (&g_shared_mutables.min_timer) is a (long long *). The cast should be
   // safe since we know that both are pointer types and 64-bit wide
@@ -651,7 +651,7 @@ static grpc_timer_check_result run_some_expired_timers(grpc_millis now,
     }
 
 #if GPR_ARCH_64
-    // TODO: sreek - Using c-style cast here. static_cast<> gives an error (on
+    // TODO(sreek): Using c-style cast here. static_cast<> gives an error (on
     // mac platforms complaining that gpr_atm* is (long *) while
     // (&g_shared_mutables.min_timer) is a (long long *). The cast should be
     // safe since we know that both are pointer types and 64-bit wide

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

@@ -342,8 +342,8 @@ void grpc_timer_manager_shutdown(void) {
   gpr_cv_destroy(&g_cv_shutdown);
 }
 
-void grpc_timer_manager_set_threading(bool threaded) {
-  if (threaded) {
+void grpc_timer_manager_set_threading(bool enabled) {
+  if (enabled) {
     start_threads();
   } else {
     stop_threads();

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

@@ -570,8 +570,7 @@ static int add_socket_to_server(grpc_udp_server* s, int fd,
   return port;
 }
 
-int grpc_udp_server_add_port(grpc_udp_server* s,
-                             const grpc_resolved_address* addr,
+int grpc_udp_server_add_port(grpc_udp_server* s, grpc_resolved_address* addr,
                              int rcv_buf_size, int snd_buf_size,
                              GrpcUdpHandlerFactory* handler_factory,
                              size_t num_listeners) {

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

@@ -93,8 +93,7 @@ int grpc_udp_server_get_fd(grpc_udp_server* s, unsigned port_index);
 
 /* TODO(ctiller): deprecate this, and make grpc_udp_server_add_ports to handle
                   all of the multiple socket port matching logic in one place */
-int grpc_udp_server_add_port(grpc_udp_server* s,
-                             const grpc_resolved_address* addr,
+int grpc_udp_server_add_port(grpc_udp_server* s, grpc_resolved_address* addr,
                              int rcv_buf_size, int snd_buf_size,
                              GrpcUdpHandlerFactory* handler_factory,
                              size_t num_listeners);

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

@@ -30,6 +30,7 @@
 
 #include "absl/strings/str_cat.h"
 
+#include "src/core/lib/iomgr/parse_address.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 
 #include <grpc/support/alloc.h>
@@ -41,27 +42,24 @@ void grpc_create_socketpair_if_unix(int sv[2]) {
   GPR_ASSERT(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0);
 }
 
-grpc_error* grpc_resolve_unix_domain_address(const char* name,
-                                             grpc_resolved_addresses** addrs) {
-  struct sockaddr_un* un;
-  if (strlen(name) >
-      GPR_ARRAY_SIZE(((struct sockaddr_un*)nullptr)->sun_path) - 1) {
-    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        absl::StrCat("Path name should not have more than ",
-                     GPR_ARRAY_SIZE(un->sun_path) - 1, " characters")
-            .c_str());
-  }
-  *addrs = static_cast<grpc_resolved_addresses*>(
+grpc_error* grpc_resolve_unix_domain_address(
+    const char* name, grpc_resolved_addresses** addresses) {
+  *addresses = static_cast<grpc_resolved_addresses*>(
+      gpr_malloc(sizeof(grpc_resolved_addresses)));
+  (*addresses)->naddrs = 1;
+  (*addresses)->addrs = static_cast<grpc_resolved_address*>(
+      gpr_malloc(sizeof(grpc_resolved_address)));
+  return grpc_core::UnixSockaddrPopulate(name, (*addresses)->addrs);
+}
+
+grpc_error* grpc_resolve_unix_abstract_domain_address(
+    const absl::string_view name, grpc_resolved_addresses** addresses) {
+  *addresses = static_cast<grpc_resolved_addresses*>(
       gpr_malloc(sizeof(grpc_resolved_addresses)));
-  (*addrs)->naddrs = 1;
-  (*addrs)->addrs = static_cast<grpc_resolved_address*>(
+  (*addresses)->naddrs = 1;
+  (*addresses)->addrs = static_cast<grpc_resolved_address*>(
       gpr_malloc(sizeof(grpc_resolved_address)));
-  un = reinterpret_cast<struct sockaddr_un*>((*addrs)->addrs->addr);
-  un->sun_family = AF_UNIX;
-  strncpy(un->sun_path, name, sizeof(un->sun_path));
-  (*addrs)->addrs->len =
-      static_cast<socklen_t>(strlen(un->sun_path) + sizeof(un->sun_family) + 1);
-  return GRPC_ERROR_NONE;
+  return grpc_core::UnixAbstractSockaddrPopulate(name, (*addresses)->addrs);
 }
 
 int grpc_is_unix_socket(const grpc_resolved_address* resolved_addr) {
@@ -79,8 +77,13 @@ void grpc_unlink_if_unix_domain_socket(
   }
   struct sockaddr_un* un = reinterpret_cast<struct sockaddr_un*>(
       const_cast<char*>(resolved_addr->addr));
-  struct stat st;
 
+  // There is nothing to unlink for an abstract unix socket
+  if (un->sun_path[0] == '\0' && un->sun_path[1] != '\0') {
+    return;
+  }
+
+  struct stat st;
   if (stat(un->sun_path, &st) == 0 && (st.st_mode & S_IFMT) == S_IFSOCK) {
     unlink(un->sun_path);
   }
@@ -93,7 +96,15 @@ std::string grpc_sockaddr_to_uri_unix_if_possible(
   if (addr->sa_family != AF_UNIX) {
     return "";
   }
-  return absl::StrCat("unix:", ((struct sockaddr_un*)addr)->sun_path);
+  const auto* unix_addr = reinterpret_cast<const struct sockaddr_un*>(addr);
+  if (unix_addr->sun_path[0] == '\0' && unix_addr->sun_path[1] != '\0') {
+    return absl::StrCat(
+        "unix-abstract:",
+        absl::string_view(
+            unix_addr->sun_path + 1,
+            resolved_addr->len - sizeof(unix_addr->sun_family) - 1));
+  }
+  return absl::StrCat("unix:", unix_addr->sun_path);
 }
 
 #endif

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

@@ -29,11 +29,16 @@
 
 #include "src/core/lib/iomgr/resolve_address.h"
 
+#include "absl/strings/string_view.h"
+
 void grpc_create_socketpair_if_unix(int sv[2]);
 
 grpc_error* grpc_resolve_unix_domain_address(
     const char* name, grpc_resolved_addresses** addresses);
 
+grpc_error* grpc_resolve_unix_abstract_domain_address(
+    absl::string_view name, grpc_resolved_addresses** addresses);
+
 int grpc_is_unix_socket(const grpc_resolved_address* resolved_addr);
 
 void grpc_unlink_if_unix_domain_socket(

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

@@ -40,6 +40,13 @@ grpc_error* grpc_resolve_unix_domain_address(
       "Unix domain sockets are not supported on Windows");
 }
 
+grpc_error* grpc_resolve_unix_abstract_domain_address(
+    absl::string_view, grpc_resolved_addresses** addresses) {
+  *addresses = NULL;
+  return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+      "Unix domain sockets are not supported on Windows");
+}
+
 int grpc_is_unix_socket(const grpc_resolved_address* addr) { return false; }
 
 void grpc_unlink_if_unix_domain_socket(const grpc_resolved_address* addr) {}

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

@@ -71,8 +71,8 @@ static grpc_error* pipe_consume(grpc_wakeup_fd* fd_info) {
 
 static grpc_error* pipe_wakeup(grpc_wakeup_fd* fd_info) {
   char c = 0;
-  while (write(fd_info->write_fd, &c, 1) != 1 && errno == EINTR)
-    ;
+  while (write(fd_info->write_fd, &c, 1) != 1 && errno == EINTR) {
+  }
   return GRPC_ERROR_NONE;
 }
 

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

@@ -68,14 +68,15 @@ class Json {
   }
 
   // Moveable.
-  Json(Json&& other) { MoveFrom(std::move(other)); }
-  Json& operator=(Json&& other) {
+  Json(Json&& other) noexcept { MoveFrom(std::move(other)); }
+  Json& operator=(Json&& other) noexcept {
     MoveFrom(std::move(other));
     return *this;
   }
 
   // Construct from copying a string.
   // If is_number is true, the type will be NUMBER instead of STRING.
+  // NOLINTNEXTLINE(google-explicit-constructor)
   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) {
@@ -85,12 +86,14 @@ class Json {
   }
 
   // Same thing for C-style strings, both const and mutable.
+  // NOLINTNEXTLINE(google-explicit-constructor)
   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;
   }
+  // NOLINTNEXTLINE(google-explicit-constructor)
   Json(char* string, bool is_number = false)
       : Json(std::string(string), is_number) {}
   Json& operator=(char* string) {
@@ -99,6 +102,7 @@ class Json {
   }
 
   // Construct by moving a string.
+  // NOLINTNEXTLINE(google-explicit-constructor)
   Json(std::string&& string)
       : type_(Type::STRING), string_value_(std::move(string)) {}
   Json& operator=(std::string&& string) {
@@ -108,6 +112,7 @@ class Json {
   }
 
   // Construct from bool.
+  // NOLINTNEXTLINE(google-explicit-constructor)
   Json(bool b) : type_(b ? Type::JSON_TRUE : Type::JSON_FALSE) {}
   Json& operator=(bool b) {
     type_ = b ? Type::JSON_TRUE : Type::JSON_FALSE;
@@ -116,6 +121,7 @@ class Json {
 
   // Construct from any numeric type.
   template <typename NumericType>
+  // NOLINTNEXTLINE(google-explicit-constructor)
   Json(NumericType number)
       : type_(Type::NUMBER), string_value_(std::to_string(number)) {}
   template <typename NumericType>
@@ -126,6 +132,7 @@ class Json {
   }
 
   // Construct by copying object.
+  // NOLINTNEXTLINE(google-explicit-constructor)
   Json(const Object& object) : type_(Type::OBJECT), object_value_(object) {}
   Json& operator=(const Object& object) {
     type_ = Type::OBJECT;
@@ -134,6 +141,7 @@ class Json {
   }
 
   // Construct by moving object.
+  // NOLINTNEXTLINE(google-explicit-constructor)
   Json(Object&& object)
       : type_(Type::OBJECT), object_value_(std::move(object)) {}
   Json& operator=(Object&& object) {
@@ -143,6 +151,7 @@ class Json {
   }
 
   // Construct by copying array.
+  // NOLINTNEXTLINE(google-explicit-constructor)
   Json(const Array& array) : type_(Type::ARRAY), array_value_(array) {}
   Json& operator=(const Array& array) {
     type_ = Type::ARRAY;
@@ -151,6 +160,7 @@ class Json {
   }
 
   // Construct by moving array.
+  // NOLINTNEXTLINE(google-explicit-constructor)
   Json(Array&& array) : type_(Type::ARRAY), array_value_(std::move(array)) {}
   Json& operator=(Array&& array) {
     type_ = Type::ARRAY;