grpc 1.62.0 → 1.64.0.pre1

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

@@ -27,6 +27,7 @@
 
 #include <vector>
 
+#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 
 #include <grpc/event_engine/endpoint_config.h>
@@ -78,13 +79,21 @@ using ::grpc_event_engine::experimental::WindowsEventEngineListener;
 // one listening port
 typedef struct grpc_tcp_listener grpc_tcp_listener;
 struct grpc_tcp_listener {
+  // Buffer to hold the local and remote address.
   // This seemingly magic number comes from AcceptEx's documentation. each
   // address buffer needs to have at least 16 more bytes at their end.
+#ifdef GRPC_HAVE_UNIX_SOCKET
+  // unix addr is larger than ip addr.
+  uint8_t addresses[(sizeof(sockaddr_un) + 16) * 2] = {};
+#else
   uint8_t addresses[(sizeof(grpc_sockaddr_in6) + 16) * 2];
+#endif  // GRPC_HAVE_UNIX_SOCKET
   // This will hold the socket for the next accept.
   SOCKET new_socket;
   // The listener winsocket.
   grpc_winsocket* socket;
+  // address of listener
+  grpc_resolved_address resolved_addr;
   // The actual TCP port number.
   int port;
   unsigned port_index;
@@ -125,6 +134,35 @@ struct grpc_tcp_server {
   WindowsEventEngineListener* ee_listener;
 };
 
+// TODO(hork): This may be refactored to share with posix engine and event
+// engine.
+void unlink_if_unix_domain_socket(const grpc_resolved_address* resolved_addr) {
+#ifdef GRPC_HAVE_UNIX_SOCKET
+  const grpc_sockaddr* addr =
+      reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
+  if (addr->sa_family != AF_UNIX) {
+    return;
+  }
+  struct sockaddr_un* un =
+      reinterpret_cast<struct sockaddr_un*>(const_cast<sockaddr*>(addr));
+  // There is nothing to unlink for an abstract unix socket.
+  if (un->sun_path[0] == '\0' && un->sun_path[1] != '\0') {
+    return;
+  }
+  // For windows we need to remove the file instead of unlink.
+  DWORD attr = ::GetFileAttributesA(un->sun_path);
+  if (attr == INVALID_FILE_ATTRIBUTES) {
+    return;
+  }
+  if (attr & FILE_ATTRIBUTE_DIRECTORY || attr & FILE_ATTRIBUTE_READONLY) {
+    return;
+  }
+  ::DeleteFileA(un->sun_path);
+#else
+  (void)resolved_addr;
+#endif
+}
+
 // Public function. Allocates the proper data structures to hold a
 // grpc_tcp_server.
 static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
@@ -158,6 +196,7 @@ static void destroy_server(void* arg, grpc_error_handle /* error */) {
     s->head = sp->next;
     sp->next = NULL;
     grpc_winsocket_destroy(sp->socket);
+    unlink_if_unix_domain_socket(&sp->resolved_addr);
     gpr_free(sp);
   }
   gpr_mu_destroy(&s->mu);
@@ -222,12 +261,15 @@ static grpc_error_handle prepare_socket(SOCKET sock,
   grpc_resolved_address sockname_temp;
   grpc_error_handle error;
   int sockname_temp_len;
-
-  error = grpc_tcp_prepare_socket(sock);
+  if (grpc_sockaddr_get_family(addr) == AF_UNIX) {
+    error = grpc_tcp_set_non_block(sock);
+  } else {
+    error = grpc_tcp_prepare_socket(sock);
+  }
   if (!error.ok()) {
     goto failure;
   }
-
+  unlink_if_unix_domain_socket(addr);
   if (bind(sock, (const grpc_sockaddr*)addr->addr, (int)addr->len) ==
       SOCKET_ERROR) {
     error = GRPC_WSA_ERROR(WSAGetLastError(), "bind");
@@ -251,7 +293,7 @@ static grpc_error_handle prepare_socket(SOCKET sock,
   return absl::OkStatus();
 
 failure:
-  GPR_ASSERT(!error.ok());
+  CHECK(!error.ok());
   auto addr_uri = grpc_sockaddr_to_uri(addr);
   error = grpc_error_set_int(
       grpc_error_set_str(
@@ -266,7 +308,7 @@ failure:
 
 static void decrement_active_ports_and_notify_locked(grpc_tcp_listener* sp) {
   sp->shutting_down = 0;
-  GPR_ASSERT(sp->server->active_ports > 0);
+  CHECK_GT(sp->server->active_ports, 0u);
   if (0 == --sp->server->active_ports) {
     finish_shutdown_locked(sp->server);
   }
@@ -277,22 +319,28 @@ static void decrement_active_ports_and_notify_locked(grpc_tcp_listener* sp) {
 static grpc_error_handle start_accept_locked(grpc_tcp_listener* port) {
   SOCKET sock = INVALID_SOCKET;
   BOOL success;
-  DWORD addrlen = sizeof(grpc_sockaddr_in6) + 16;
+  const DWORD addrlen = sizeof(port->addresses) / 2;
   DWORD bytes_received = 0;
   grpc_error_handle error;
 
   if (port->shutting_down) {
     return absl::OkStatus();
   }
-
-  sock = WSASocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, NULL, 0,
+  const int addr_family =
+      grpc_sockaddr_get_family(&port->resolved_addr) == AF_UNIX ? AF_UNIX
+                                                                : AF_INET6;
+  const int protocol = addr_family == AF_UNIX ? 0 : IPPROTO_TCP;
+  sock = WSASocket(addr_family, SOCK_STREAM, protocol, NULL, 0,
                    grpc_get_default_wsa_socket_flags());
   if (sock == INVALID_SOCKET) {
     error = GRPC_WSA_ERROR(WSAGetLastError(), "WSASocket");
     goto failure;
   }
-
-  error = grpc_tcp_prepare_socket(sock);
+  if (addr_family == AF_UNIX) {
+    error = grpc_tcp_set_non_block(sock);
+  } else {
+    error = grpc_tcp_prepare_socket(sock);
+  }
   if (!error.ok()) goto failure;
 
   // Start the "accept" asynchronously.
@@ -318,7 +366,7 @@ static grpc_error_handle start_accept_locked(grpc_tcp_listener* port) {
   return error;
 
 failure:
-  GPR_ASSERT(!error.ok());
+  CHECK(!error.ok());
   if (sock != INVALID_SOCKET) closesocket(sock);
   return error;
 }
@@ -411,7 +459,7 @@ static void on_accept(void* arg, grpc_error_handle error) {
   // the former socked we created has now either been destroy or assigned
   // to the new connection. We need to create a new one for the next
   // connection.
-  GPR_ASSERT(GRPC_LOG_IF_ERROR("start_accept", start_accept_locked(sp)));
+  CHECK(GRPC_LOG_IF_ERROR("start_accept", start_accept_locked(sp)));
   if (0 == --sp->outstanding_calls) {
     decrement_active_ports_and_notify_locked(sp);
   }
@@ -447,7 +495,7 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, SOCKET sock,
     return error;
   }
 
-  GPR_ASSERT(port >= 0);
+  CHECK_GE(port, 0);
   gpr_mu_lock(&s->mu);
   sp = (grpc_tcp_listener*)gpr_malloc(sizeof(grpc_tcp_listener));
   sp->next = NULL;
@@ -463,10 +511,11 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, SOCKET sock,
   sp->outstanding_calls = 0;
   sp->AcceptEx = AcceptEx;
   sp->new_socket = INVALID_SOCKET;
+  sp->resolved_addr = *addr;
   sp->port = port;
   sp->port_index = port_index;
   GRPC_CLOSURE_INIT(&sp->on_accept, on_accept, sp, grpc_schedule_on_exec_ctx);
-  GPR_ASSERT(sp->socket);
+  CHECK(sp->socket);
   gpr_mu_unlock(&s->mu);
   *listener = sp;
 
@@ -522,7 +571,10 @@ static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
     addr = &wildcard;
   }
 
-  sock = WSASocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, NULL, 0,
+  const int addr_family =
+      grpc_sockaddr_get_family(addr) == AF_UNIX ? AF_UNIX : AF_INET6;
+  const int protocol = addr_family == AF_UNIX ? 0 : IPPROTO_TCP;
+  sock = WSASocket(addr_family, SOCK_STREAM, protocol, NULL, 0,
                    grpc_get_default_wsa_socket_flags());
   if (sock == INVALID_SOCKET) {
     error = GRPC_WSA_ERROR(WSAGetLastError(), "WSASocket");
@@ -540,7 +592,7 @@ done:
     error = error_out;
     *port = -1;
   } else {
-    GPR_ASSERT(sp != NULL);
+    CHECK(sp != NULL);
     *port = sp->port;
   }
   return error;
@@ -550,9 +602,9 @@ static void tcp_server_start(grpc_tcp_server* s,
                              const std::vector<grpc_pollset*>* /*pollsets*/) {
   grpc_tcp_listener* sp;
   gpr_mu_lock(&s->mu);
-  GPR_ASSERT(s->active_ports == 0);
+  CHECK_EQ(s->active_ports, 0u);
   for (sp = s->head; sp; sp = sp->next) {
-    GPR_ASSERT(GRPC_LOG_IF_ERROR("start_accept", start_accept_locked(sp)));
+    CHECK(GRPC_LOG_IF_ERROR("start_accept", start_accept_locked(sp)));
     s->active_ports++;
   }
   gpr_mu_unlock(&s->mu);
@@ -602,7 +654,7 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
   WindowsEventEngine* engine_ptr = reinterpret_cast<WindowsEventEngine*>(
       config.GetVoidPointer(GRPC_INTERNAL_ARG_EVENT_ENGINE));
   grpc_tcp_server* s = (grpc_tcp_server*)gpr_malloc(sizeof(grpc_tcp_server));
-  GPR_ASSERT(on_accept_cb != nullptr);
+  CHECK_NE(on_accept_cb, nullptr);
   auto accept_cb = [s, on_accept_cb, on_accept_cb_arg](
                        std::unique_ptr<EventEngine::Endpoint> endpoint,
                        MemoryAllocator memory_allocator) {
@@ -624,7 +676,7 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
   grpc_core::RefCountedPtr<grpc_core::ResourceQuota> resource_quota;
   {
     void* tmp_quota = config.GetVoidPointer(GRPC_ARG_RESOURCE_QUOTA);
-    GPR_ASSERT(tmp_quota != nullptr);
+    CHECK_NE(tmp_quota, nullptr);
     resource_quota =
         reinterpret_cast<grpc_core::ResourceQuota*>(tmp_quota)->Ref();
   }
@@ -655,13 +707,13 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
 
 static void event_engine_start(grpc_tcp_server* s,
                                const std::vector<grpc_pollset*>* /*pollsets*/) {
-  GPR_ASSERT(s->ee_listener->Start().ok());
+  CHECK(s->ee_listener->Start().ok());
 }
 
 static grpc_error_handle event_engine_add_port(
     grpc_tcp_server* s, const grpc_resolved_address* addr, int* port) {
-  GPR_ASSERT(addr != nullptr);
-  GPR_ASSERT(port != nullptr);
+  CHECK_NE(addr, nullptr);
+  CHECK_NE(port, nullptr);
   auto ee_addr = CreateResolvedAddress(*addr);
   auto out_port = s->ee_listener->Bind(ee_addr);
   *port = out_port.ok() ? *out_port : -1;

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

@@ -24,6 +24,8 @@
 
 #include <limits.h>
 
+#include "absl/log/check.h"
+
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -190,7 +192,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
       grpc_slice_buffer_reset_and_unref(tcp->read_slices);
     } else {
       if (info->bytes_transferred != 0 && !tcp->shutting_down) {
-        GPR_ASSERT((size_t)info->bytes_transferred <= tcp->read_slices->length);
+        CHECK((size_t)info->bytes_transferred <= tcp->read_slices->length);
         if (static_cast<size_t>(info->bytes_transferred) !=
             tcp->read_slices->length) {
           grpc_slice_buffer_trim_end(
@@ -199,7 +201,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
                   static_cast<size_t>(info->bytes_transferred),
               &tcp->last_read_buffer);
         }
-        GPR_ASSERT((size_t)info->bytes_transferred == tcp->read_slices->length);
+        CHECK((size_t)info->bytes_transferred == tcp->read_slices->length);
 
         if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace) &&
             gpr_should_log(GPR_LOG_SEVERITY_INFO)) {
@@ -272,7 +274,7 @@ static void win_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
                           GRPC_SLICE_MALLOC(DEFAULT_TARGET_READ_SIZE));
   }
 
-  GPR_ASSERT(tcp->read_slices->count <= MAX_WSABUF_COUNT);
+  CHECK(tcp->read_slices->count <= MAX_WSABUF_COUNT);
   for (i = 0; i < tcp->read_slices->count; i++) {
     buffers[i].len = (ULONG)GRPC_SLICE_LENGTH(
         tcp->read_slices->slices[i]);  // we know slice size fits in 32bit.
@@ -331,7 +333,7 @@ static void on_write(void* tcpp, grpc_error_handle error) {
     if (info->wsa_error != 0) {
       error = GRPC_WSA_ERROR(info->wsa_error, "WSASend");
     } else {
-      GPR_ASSERT(info->bytes_transferred <= tcp->write_slices->length);
+      CHECK(info->bytes_transferred <= tcp->write_slices->length);
     }
   }
 
@@ -378,7 +380,7 @@ static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
 
   tcp->write_cb = cb;
   tcp->write_slices = slices;
-  GPR_ASSERT(tcp->write_slices->count <= UINT_MAX);
+  CHECK(tcp->write_slices->count <= UINT_MAX);
   if (tcp->write_slices->count > GPR_ARRAY_SIZE(local_buffers)) {
     buffers = (WSABUF*)gpr_malloc(sizeof(WSABUF) * tcp->write_slices->count);
     allocated = buffers;
@@ -386,7 +388,7 @@ static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
 
   for (i = 0; i < tcp->write_slices->count; i++) {
     len = GRPC_SLICE_LENGTH(tcp->write_slices->slices[i]);
-    GPR_ASSERT(len <= ULONG_MAX);
+    CHECK(len <= ULONG_MAX);
     buffers[i].len = (ULONG)len;
     buffers[i].buf = (char*)GRPC_SLICE_START_PTR(tcp->write_slices->slices[i]);
   }

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

@@ -16,10 +16,10 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/iomgr/timer.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/iomgr/timer_manager.h"
 
 grpc_timer_vtable* grpc_timer_impl;

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

@@ -19,11 +19,10 @@
 #ifndef GRPC_SRC_CORE_LIB_IOMGR_TIMER_H
 #define GRPC_SRC_CORE_LIB_IOMGR_TIMER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <cstdint>
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
 #include "src/core/lib/iomgr/exec_ctx.h"

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

@@ -16,18 +16,18 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <inttypes.h>
 
 #include <string>
 
+#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/cpu.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/debug/trace.h"
@@ -121,7 +121,7 @@ static bool is_in_ht(grpc_timer* t) {
 }
 
 static void add_to_ht(grpc_timer* t) {
-  GPR_ASSERT(!t->hash_table_next);
+  CHECK(!t->hash_table_next);
   size_t i = grpc_core::HashPointer(t, NUM_HASH_BUCKETS);
 
   gpr_mu_lock(&g_hash_mu[i]);

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

@@ -20,7 +20,6 @@
 #define GRPC_SRC_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"

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

@@ -16,13 +16,12 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/iomgr/timer_heap.h"
 
 #include <string.h>
 
 #include <grpc/support/alloc.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/port.h"

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

@@ -16,14 +16,15 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/iomgr/timer_manager.h"
 
 #include <inttypes.h>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/crash.h"
@@ -83,7 +84,7 @@ static void gc_completed_threads(void) {
 }
 
 static void start_timer_thread_and_unlock(void) {
-  GPR_ASSERT(g_threaded);
+  CHECK(g_threaded);
   ++g_waiter_count;
   ++g_thread_count;
   gpr_mu_unlock(&g_mu);

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

@@ -19,10 +19,10 @@
 #ifndef GRPC_SRC_CORE_LIB_IOMGR_TIMER_MANAGER_H
 #define GRPC_SRC_CORE_LIB_IOMGR_TIMER_MANAGER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdbool.h>
 
+#include <grpc/support/port_platform.h>
+
 // Timer Manager tries to keep only one thread waiting for the next timeout at
 // all times, and thus effectively preventing the thundering herd problem.
 

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

@@ -24,8 +24,16 @@
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
+#ifdef GPR_WINDOWS
+// clang-format off
+#include <ws2def.h>
+#include <afunix.h>
+// clang-format on
+#else
 #include <sys/un.h>
+#endif  // GPR_WINDOWS
 
+#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 
 #include <grpc/support/alloc.h>
@@ -39,7 +47,11 @@
 #include "src/core/lib/transport/error_utils.h"
 
 void grpc_create_socketpair_if_unix(int sv[2]) {
-  GPR_ASSERT(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0);
+#ifdef GPR_WINDOWS
+  grpc_core::Crash("AF_UNIX socket pairs are not supported on Windows");
+#else
+  CHECK_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, sv), 0);
+#endif
 }
 
 absl::StatusOr<std::vector<grpc_resolved_address>>
@@ -86,10 +98,12 @@ void grpc_unlink_if_unix_domain_socket(
     return;
   }
 
+#ifndef GPR_WINDOWS
   struct stat st;
   if (stat(un->sun_path, &st) == 0 && (st.st_mode & S_IFMT) == S_IFSOCK) {
     unlink(un->sun_path);
   }
+#endif
 }
 
 #endif

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

@@ -19,12 +19,11 @@
 #ifndef GRPC_SRC_CORE_LIB_IOMGR_UNIX_SOCKETS_POSIX_H
 #define GRPC_SRC_CORE_LIB_IOMGR_UNIX_SOCKETS_POSIX_H
 
-#include <grpc/support/port_platform.h>
-
 #include <string>
 
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/iomgr/port.h"

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

@@ -24,6 +24,8 @@
 
 #include <string>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/crash.h"
@@ -32,7 +34,7 @@ void grpc_create_socketpair_if_unix(int /* sv */[2]) {
   // TODO: Either implement this for the non-Unix socket case or make
   // sure that it is never called in any such case. Until then, leave an
   // assertion to notify if this gets called inadvertently
-  GPR_ASSERT(0);
+  CHECK(0);
 }
 
 absl::StatusOr<std::vector<grpc_resolved_address>>

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

@@ -15,10 +15,10 @@
 // limitations under the License.
 //
 //
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/iomgr/vsock.h"
 
+#include <grpc/support/port_platform.h>
+
 #ifdef GRPC_HAVE_VSOCK
 
 #include <string.h>

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

@@ -19,12 +19,11 @@
 #ifndef GRPC_SRC_CORE_LIB_IOMGR_VSOCK_H
 #define GRPC_SRC_CORE_LIB_IOMGR_VSOCK_H
 
-#include <grpc/support/port_platform.h>
-
 #include <string>
 
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/iomgr/port.h"

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

@@ -17,9 +17,8 @@
 #ifndef GRPC_SRC_CORE_LIB_JSON_JSON_H
 #define GRPC_SRC_CORE_LIB_JSON_JSON_H
 
-#include <grpc/support/port_platform.h>
-
 #include <grpc/support/json.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_core {
 

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

@@ -15,10 +15,10 @@
 #ifndef GRPC_SRC_CORE_LIB_JSON_JSON_ARGS_H
 #define GRPC_SRC_CORE_LIB_JSON_JSON_ARGS_H
 
-#include <grpc/support/port_platform.h>
-
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_core {
 
 class JsonArgs {

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

@@ -15,11 +15,11 @@
 #ifndef GRPC_SRC_CORE_LIB_JSON_JSON_CHANNEL_ARGS_H
 #define GRPC_SRC_CORE_LIB_JSON_JSON_CHANNEL_ARGS_H
 
-#include <grpc/support/port_platform.h>
-
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/json/json_args.h"
 

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

@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/json/json_object_loader.h"
 
 #include <utility>
@@ -23,6 +21,7 @@
 #include "absl/strings/strip.h"
 
 #include <grpc/support/json.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_core {
 namespace json_detail {

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

@@ -15,8 +15,6 @@
 #ifndef GRPC_SRC_CORE_LIB_JSON_JSON_OBJECT_LOADER_H
 #define GRPC_SRC_CORE_LIB_JSON_JSON_OBJECT_LOADER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <cstdint>
 #include <cstring>
 #include <map>
@@ -32,6 +30,8 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/gprpp/no_destruct.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"

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

@@ -14,8 +14,6 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <inttypes.h>
 #include <stdlib.h>
 
@@ -26,6 +24,7 @@
 #include <vector>
 
 #include "absl/base/attributes.h"
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -36,6 +35,7 @@
 
 #include <grpc/support/json.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/match.h"
 #include "src/core/lib/json/json.h"
@@ -280,14 +280,14 @@ bool JsonReader::StartContainer(Json::Type type) {
   if (type == Json::Type::kObject) {
     scope.data = Json::Object();
   } else {
-    GPR_ASSERT(type == Json::Type::kArray);
+    CHECK(type == Json::Type::kArray);
     scope.data = Json::Array();
   }
   return true;
 }
 
 void JsonReader::EndContainer() {
-  GPR_ASSERT(!stack_.empty());
+  CHECK(!stack_.empty());
   Scope scope = std::move(stack_.back());
   stack_.pop_back();
   key_ = std::move(scope.parent_object_key);

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

@@ -17,11 +17,11 @@
 #ifndef GRPC_SRC_CORE_LIB_JSON_JSON_READER_H
 #define GRPC_SRC_CORE_LIB_JSON_JSON_READER_H
 
-#include <grpc/support/port_platform.h>
-
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/json/json.h"
 
 namespace grpc_core {