grpc 1.62.0 → 1.64.0

data/src/core/lib/event_engine/thready_event_engine/thready_event_engine.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/event_engine/thready_event_engine/thready_event_engine.h"
 
 #include <memory>
@@ -21,6 +19,8 @@
 #include <type_traits>
 #include <vector>
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/thd.h"
 

data/src/core/lib/event_engine/thready_event_engine/thready_event_engine.h

@@ -15,8 +15,6 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREADY_EVENT_ENGINE_THREADY_EVENT_ENGINE_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREADY_EVENT_ENGINE_THREADY_EVENT_ENGINE_H
 
-#include <grpc/support/port_platform.h>
-
 #include <memory>
 #include <utility>
 
@@ -28,6 +26,7 @@
 #include <grpc/event_engine/endpoint_config.h>
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/event_engine/memory_allocator.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_event_engine {
 namespace experimental {

data/src/core/lib/event_engine/time_util.cc

@@ -11,13 +11,12 @@
 // 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/event_engine/time_util.h"
 
 #include <chrono>
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_event_engine {
 namespace experimental {

data/src/core/lib/event_engine/time_util.h

@@ -14,11 +14,10 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_TIME_UTIL_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_TIME_UTIL_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_event_engine {
 namespace experimental {

data/src/core/lib/event_engine/trace.cc

@@ -11,10 +11,10 @@
 // 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/debug/trace.h"
 
+#include <grpc/support/port_platform.h>
+
 grpc_core::TraceFlag grpc_event_engine_trace(false, "event_engine");
 grpc_core::TraceFlag grpc_event_engine_dns_trace(false, "event_engine_dns");
 grpc_core::TraceFlag grpc_event_engine_endpoint_trace(false,

data/src/core/lib/event_engine/trace.h

@@ -14,9 +14,8 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_TRACE_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_TRACE_H
 
-#include <grpc/support/port_platform.h>
-
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
 

data/src/core/lib/event_engine/utils.cc

@@ -11,8 +11,6 @@
 // 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/event_engine/utils.h"
 
 #include <stdint.h>
@@ -22,6 +20,7 @@
 #include "absl/strings/str_cat.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/time.h"
 

data/src/core/lib/event_engine/utils.h

@@ -14,13 +14,12 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_UTILS_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_UTILS_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 
 #include <string>
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/time.h"
 

data/src/core/lib/event_engine/windows/grpc_polled_fd_windows.cc

@@ -23,6 +23,7 @@
 #include <ares.h>
 
 #include "absl/functional/any_invocable.h"
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 
@@ -132,8 +133,8 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
         shutdown_called_);
     grpc_core::CSliceUnref(read_buf_);
     grpc_core::CSliceUnref(write_buf_);
-    GPR_ASSERT(read_closure_ == nullptr);
-    GPR_ASSERT(write_closure_ == nullptr);
+    CHECK(read_closure_ == nullptr);
+    CHECK(write_closure_ == nullptr);
     if (!shutdown_called_) {
       winsocket_->Shutdown(DEBUG_LOCATION, "~GrpcPolledFdWindows");
     }
@@ -141,15 +142,15 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
 
   void RegisterForOnReadableLocked(
       absl::AnyInvocable<void(absl::Status)> read_closure) override {
-    GPR_ASSERT(read_closure_ == nullptr);
+    CHECK(read_closure_ == nullptr);
     read_closure_ = std::move(read_closure);
     grpc_core::CSliceUnref(read_buf_);
-    GPR_ASSERT(!read_buf_has_data_);
+    CHECK(!read_buf_has_data_);
     read_buf_ = GRPC_SLICE_MALLOC(kReadBufferSize);
     if (connect_done_) {
       ContinueRegisterForOnReadableLocked();
     } else {
-      GPR_ASSERT(pending_continue_register_for_on_readable_locked_ == false);
+      CHECK(pending_continue_register_for_on_readable_locked_ == false);
       pending_continue_register_for_on_readable_locked_ = true;
     }
   }
@@ -160,16 +161,16 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
       GRPC_ARES_RESOLVER_TRACE_LOG(
           "fd:|%s| RegisterForOnWriteableLocked called", GetName());
     } else {
-      GPR_ASSERT(socket_type_ == SOCK_STREAM);
+      CHECK(socket_type_ == SOCK_STREAM);
       GRPC_ARES_RESOLVER_TRACE_LOG(
           "fd:|%s| RegisterForOnWriteableLocked called tcp_write_state_: %d "
           "connect_done_: %d",
           GetName(), tcp_write_state_, connect_done_);
     }
-    GPR_ASSERT(write_closure_ == nullptr);
+    CHECK(write_closure_ == nullptr);
     write_closure_ = std::move(write_closure);
     if (!connect_done_) {
-      GPR_ASSERT(!pending_continue_register_for_on_writeable_locked_);
+      CHECK(!pending_continue_register_for_on_writeable_locked_);
       pending_continue_register_for_on_writeable_locked_ = true;
     } else {
       ContinueRegisterForOnWriteableLocked();
@@ -179,7 +180,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
   bool IsFdStillReadableLocked() override { return read_buf_has_data_; }
 
   bool ShutdownLocked(absl::Status error) override {
-    GPR_ASSERT(!shutdown_called_);
+    CHECK(!shutdown_called_);
     if (!absl::IsCancelled(error)) {
       return false;
     }
@@ -223,7 +224,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
     // c-ares overloads this recv_from virtual socket function to receive
     // data on both UDP and TCP sockets, and from is nullptr for TCP.
     if (from != nullptr) {
-      GPR_ASSERT(*from_len <= recv_from_source_addr_len_);
+      CHECK(*from_len <= recv_from_source_addr_len_);
       memcpy(from, &recv_from_source_addr_, recv_from_source_addr_len_);
       *from_len = recv_from_source_addr_len_;
     }
@@ -291,7 +292,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
         "fd:|%s| ContinueRegisterForOnReadableLocked "
         "wsa_connect_error_:%d",
         GetName(), wsa_connect_error_);
-    GPR_ASSERT(connect_done_);
+    CHECK(connect_done_);
     if (wsa_connect_error_ != 0) {
       ScheduleAndNullReadClosure(GRPC_WSA_ERROR(wsa_connect_error_, "connect"));
       return;
@@ -328,7 +329,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
         "fd:|%s| ContinueRegisterForOnWriteableLocked "
         "wsa_connect_error_:%d",
         GetName(), wsa_connect_error_);
-    GPR_ASSERT(connect_done_);
+    CHECK(connect_done_);
     if (wsa_connect_error_ != 0) {
       ScheduleAndNullWriteClosure(
           GRPC_WSA_ERROR(wsa_connect_error_, "connect"));
@@ -338,7 +339,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
       ScheduleAndNullWriteClosure(absl::OkStatus());
       return;
     }
-    GPR_ASSERT(socket_type_ == SOCK_STREAM);
+    CHECK(socket_type_ == SOCK_STREAM);
     int wsa_error_code = 0;
     switch (tcp_write_state_) {
       case WRITE_IDLE:
@@ -386,7 +387,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
     // Therefore, the sendv handler for UDP sockets must only attempt
     // to write everything inline.
     GRPC_ARES_RESOLVER_TRACE_LOG("fd:|%s| SendVUDP called", GetName());
-    GPR_ASSERT(GRPC_SLICE_LENGTH(write_buf_) == 0);
+    CHECK_EQ(GRPC_SLICE_LENGTH(write_buf_), 0);
     grpc_core::CSliceUnref(write_buf_);
     write_buf_ = FlattenIovec(iov, iov_count);
     DWORD bytes_sent = 0;
@@ -434,12 +435,12 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
         // send again. If c-ares still needs to send even more data, we'll get
         // to it eventually.
         grpc_slice currently_attempted = FlattenIovec(iov, iov_count);
-        GPR_ASSERT(GRPC_SLICE_LENGTH(currently_attempted) >=
-                   GRPC_SLICE_LENGTH(write_buf_));
+        CHECK(GRPC_SLICE_LENGTH(currently_attempted) >=
+              GRPC_SLICE_LENGTH(write_buf_));
         ares_ssize_t total_sent = 0;
         for (size_t i = 0; i < GRPC_SLICE_LENGTH(write_buf_); i++) {
-          GPR_ASSERT(GRPC_SLICE_START_PTR(currently_attempted)[i] ==
-                     GRPC_SLICE_START_PTR(write_buf_)[i]);
+          CHECK(GRPC_SLICE_START_PTR(currently_attempted)[i] ==
+                GRPC_SLICE_START_PTR(write_buf_)[i]);
           total_sent++;
         }
         grpc_core::CSliceUnref(currently_attempted);
@@ -458,9 +459,9 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
         " pending_register_for_writeable:%d",
         GetName(), pending_continue_register_for_on_readable_locked_,
         pending_continue_register_for_on_writeable_locked_);
-    GPR_ASSERT(!connect_done_);
+    CHECK(!connect_done_);
     connect_done_ = true;
-    GPR_ASSERT(wsa_connect_error_ == 0);
+    CHECK_EQ(wsa_connect_error_, 0);
     if (shutdown_called_) {
       wsa_connect_error_ = WSA_OPERATION_ABORTED;
     } else {
@@ -469,7 +470,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
       BOOL wsa_success = WSAGetOverlappedResult(
           winsocket_->raw_socket(), winsocket_->write_info()->overlapped(),
           &transferred_bytes, FALSE, &flags);
-      GPR_ASSERT(transferred_bytes == 0);
+      CHECK_EQ(transferred_bytes, 0);
       if (!wsa_success) {
         wsa_connect_error_ = WSAGetLastError();
         char* msg = gpr_format_message(wsa_connect_error_);
@@ -491,8 +492,8 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
   int ConnectUDP(WSAErrorContext* wsa_error_ctx, const struct sockaddr* target,
                  ares_socklen_t target_len) {
     GRPC_ARES_RESOLVER_TRACE_LOG("fd:%s ConnectUDP", GetName());
-    GPR_ASSERT(!connect_done_);
-    GPR_ASSERT(wsa_connect_error_ == 0);
+    CHECK(!connect_done_);
+    CHECK_EQ(wsa_connect_error_, 0);
     SOCKET s = winsocket_->raw_socket();
     int out =
         WSAConnect(s, target, target_len, nullptr, nullptr, nullptr, nullptr);
@@ -620,7 +621,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
   void OnIocpWriteable() {
     grpc_core::MutexLock lock(mu_);
     GRPC_ARES_RESOLVER_TRACE_LOG("OnIocpWriteableInner. fd:|%s|", GetName());
-    GPR_ASSERT(socket_type_ == SOCK_STREAM);
+    CHECK(socket_type_ == SOCK_STREAM);
     absl::Status error;
     if (winsocket_->write_info()->result().wsa_error != 0) {
       error = GRPC_WSA_ERROR(winsocket_->write_info()->result().wsa_error,
@@ -631,7 +632,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
           GetName(), winsocket_->write_info()->result().wsa_error,
           grpc_core::StatusToString(error).c_str());
     }
-    GPR_ASSERT(tcp_write_state_ == WRITE_PENDING);
+    CHECK(tcp_write_state_ == WRITE_PENDING);
     if (error.ok()) {
       tcp_write_state_ = WRITE_WAITING_FOR_VERIFICATION_UPON_RETRY;
       write_buf_ = grpc_slice_sub_no_ref(
@@ -712,7 +713,7 @@ class CustomSockFuncs {
     GRPC_ARES_RESOLVER_TRACE_LOG(
         "fd:|%s| created with params af:%d type:%d protocol:%d",
         polled_fd->GetName(), af, type, protocol);
-    GPR_ASSERT(self->sockets_.insert({s, std::move(polled_fd)}).second);
+    CHECK(self->sockets_.insert({s, std::move(polled_fd)}).second);
     return s;
   }
 
@@ -722,7 +723,7 @@ class CustomSockFuncs {
     GrpcPolledFdFactoryWindows* self =
         static_cast<GrpcPolledFdFactoryWindows*>(user_data);
     auto it = self->sockets_.find(as);
-    GPR_ASSERT(it != self->sockets_.end());
+    CHECK(it != self->sockets_.end());
     return it->second->Connect(&wsa_error_ctx, target, target_len);
   }
 
@@ -732,7 +733,7 @@ class CustomSockFuncs {
     GrpcPolledFdFactoryWindows* self =
         static_cast<GrpcPolledFdFactoryWindows*>(user_data);
     auto it = self->sockets_.find(as);
-    GPR_ASSERT(it != self->sockets_.end());
+    CHECK(it != self->sockets_.end());
     return it->second->SendV(&wsa_error_ctx, iov, iovec_count);
   }
 
@@ -743,7 +744,7 @@ class CustomSockFuncs {
     GrpcPolledFdFactoryWindows* self =
         static_cast<GrpcPolledFdFactoryWindows*>(user_data);
     auto it = self->sockets_.find(as);
-    GPR_ASSERT(it != self->sockets_.end());
+    CHECK(it != self->sockets_.end());
     return it->second->RecvFrom(&wsa_error_ctx, data, data_len, flags, from,
                                 from_len);
   }
@@ -802,7 +803,7 @@ void GrpcPolledFdFactoryWindows::Initialize(grpc_core::Mutex* mutex,
 std::unique_ptr<GrpcPolledFd> GrpcPolledFdFactoryWindows::NewGrpcPolledFdLocked(
     ares_socket_t as) {
   auto it = sockets_.find(as);
-  GPR_ASSERT(it != sockets_.end());
+  CHECK(it != sockets_.end());
   return std::make_unique<GrpcPolledFdWrapper>(it->second.get());
 }
 

data/src/core/lib/event_engine/windows/iocp.cc

@@ -17,6 +17,7 @@
 
 #include <chrono>
 
+#include "absl/log/check.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/support/alloc.h>
@@ -37,7 +38,7 @@ IOCP::IOCP(ThreadPool* thread_pool) noexcept
     : thread_pool_(thread_pool),
       iocp_handle_(CreateIoCompletionPort(INVALID_HANDLE_VALUE, nullptr,
                                           (ULONG_PTR) nullptr, 0)) {
-  GPR_ASSERT(iocp_handle_);
+  CHECK(iocp_handle_);
   WSASocketFlagsInit();
 }
 
@@ -54,7 +55,7 @@ std::unique_ptr<WinSocket> IOCP::Watch(SOCKET socket) {
         GRPC_WSA_ERROR(WSAGetLastError(), "Unable to add socket to iocp")
             .ToString());
   }
-  GPR_ASSERT(ret == iocp_handle_);
+  CHECK(ret == iocp_handle_);
   return wrapped_socket;
 }
 
@@ -65,7 +66,7 @@ void IOCP::Shutdown() {
   while (outstanding_kicks_.load() > 0) {
     Work(std::chrono::hours(42), []() {});
   }
-  GPR_ASSERT(CloseHandle(iocp_handle_));
+  CHECK(CloseHandle(iocp_handle_));
 }
 
 Poller::WorkResult IOCP::Work(EventEngine::Duration timeout,
@@ -81,7 +82,8 @@ Poller::WorkResult IOCP::Work(EventEngine::Duration timeout,
     GRPC_EVENT_ENGINE_POLLER_TRACE("IOCP::%p deadline exceeded", this);
     return Poller::WorkResult::kDeadlineExceeded;
   }
-  GPR_ASSERT(completion_key && overlapped);
+  CHECK(completion_key);
+  CHECK(overlapped);
   if (overlapped == &kick_overlap_) {
     GRPC_EVENT_ENGINE_POLLER_TRACE("IOCP::%p kicked", this);
     outstanding_kicks_.fetch_sub(1);
@@ -100,7 +102,7 @@ Poller::WorkResult IOCP::Work(EventEngine::Duration timeout,
   // about to register for notification of an overlapped event.
   auto* socket = reinterpret_cast<WinSocket*>(completion_key);
   WinSocket::OpState* info = socket->GetOpInfoForOverlapped(overlapped);
-  GPR_ASSERT(info != nullptr);
+  CHECK_NE(info, nullptr);
   info->GetOverlappedResult();
   info->SetReady();
   schedule_poll_again();
@@ -109,9 +111,9 @@ Poller::WorkResult IOCP::Work(EventEngine::Duration timeout,
 
 void IOCP::Kick() {
   outstanding_kicks_.fetch_add(1);
-  GPR_ASSERT(PostQueuedCompletionStatus(
-      iocp_handle_, 0, reinterpret_cast<ULONG_PTR>(&kick_token_),
-      &kick_overlap_));
+  CHECK(PostQueuedCompletionStatus(iocp_handle_, 0,
+                                   reinterpret_cast<ULONG_PTR>(&kick_token_),
+                                   &kick_overlap_));
 }
 
 DWORD IOCP::GetDefaultSocketFlags() {

data/src/core/lib/event_engine/windows/win_socket.cc

@@ -14,6 +14,8 @@
 #include <grpc/support/port_platform.h>
 
 #ifdef GPR_WINDOWS
+#include "absl/log/check.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log_windows.h>
 
@@ -45,7 +47,7 @@ WinSocket::WinSocket(SOCKET socket, ThreadPool* thread_pool) noexcept
       write_info_(this) {}
 
 WinSocket::~WinSocket() {
-  GPR_ASSERT(is_shutdown_.load());
+  CHECK(is_shutdown_.load());
   GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WinSocket::%p destroyed", this);
 }
 
@@ -94,7 +96,7 @@ void WinSocket::NotifyOnReady(OpState& info, EventEngine::Closure* closure) {
     return;
   };
   // It is an error if any notification is already registered for this socket.
-  GPR_ASSERT(std::exchange(info.closure_, closure) == nullptr);
+  CHECK_EQ(std::exchange(info.closure_, closure), nullptr);
 }
 
 void WinSocket::NotifyOnRead(EventEngine::Closure* on_read) {
@@ -106,11 +108,11 @@ void WinSocket::NotifyOnWrite(EventEngine::Closure* on_write) {
 }
 
 void WinSocket::UnregisterReadCallback() {
-  GPR_ASSERT(std::exchange(read_info_.closure_, nullptr) != nullptr);
+  CHECK_NE(std::exchange(read_info_.closure_, nullptr), nullptr);
 }
 
 void WinSocket::UnregisterWriteCallback() {
-  GPR_ASSERT(std::exchange(write_info_.closure_, nullptr) != nullptr);
+  CHECK_NE(std::exchange(write_info_.closure_, nullptr), nullptr);
 }
 
 // ---- WinSocket::OpState ----
@@ -124,7 +126,7 @@ void WinSocket::OpState::SetReady() {
   auto* closure = std::exchange(closure_, nullptr);
   // If an IOCP event is returned for a socket, and no callback has been
   // registered for notification, this is invalid usage.
-  GPR_ASSERT(closure != nullptr);
+  CHECK_NE(closure, nullptr);
   win_socket_->thread_pool_->Run(closure);
 }
 
@@ -208,6 +210,10 @@ static grpc_error_handle enable_socket_low_latency(SOCKET sock) {
 
 }  // namespace
 
+absl::Status SetSocketNonBlock(SOCKET sock) {
+  return grpc_tcp_set_non_block(sock);
+}
+
 absl::Status PrepareSocket(SOCKET sock) {
   absl::Status err;
   err = grpc_tcp_set_non_block(sock);

data/src/core/lib/event_engine/windows/win_socket.h

@@ -133,6 +133,9 @@ class WinSocket {
 // Attempt to configure default socket settings
 absl::Status PrepareSocket(SOCKET sock);
 
+// Set non block option for socket.
+absl::Status SetSocketNonBlock(SOCKET sock);
+
 }  // namespace experimental
 }  // namespace grpc_event_engine
 

data/src/core/lib/event_engine/windows/windows_endpoint.cc

@@ -17,6 +17,7 @@
 
 #include "absl/cleanup/cleanup.h"
 #include "absl/functional/any_invocable.h"
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 
@@ -80,12 +81,12 @@ void WindowsEndpoint::AsyncIOState::DoTcpRead(SliceBuffer* buffer) {
   GRPC_EVENT_ENGINE_ENDPOINT_TRACE("WindowsEndpoint::%p reading", endpoint);
   if (socket->IsShutdown()) {
     socket->read_info()->SetErrorStatus(
-        absl::UnavailableError("Socket is shutting down."));
+        absl::InternalError("Socket is shutting down."));
     thread_pool->Run(&handle_read_event);
     return;
   }
   // Prepare the WSABUF struct
-  GPR_ASSERT(buffer->Count() <= kMaxWSABUFCount);
+  CHECK(buffer->Count() <= kMaxWSABUFCount);
   WSABUF wsa_buffers[kMaxWSABUFCount];
   for (size_t i = 0; i < buffer->Count(); i++) {
     auto& slice = buffer->MutableSliceAt(i);
@@ -130,7 +131,7 @@ bool WindowsEndpoint::Read(absl::AnyInvocable<void(absl::Status)> on_read,
                            SliceBuffer* buffer, const ReadArgs* /* args */) {
   if (io_state_->socket->IsShutdown()) {
     io_state_->thread_pool->Run([on_read = std::move(on_read)]() mutable {
-      on_read(absl::UnavailableError("Socket is shutting down."));
+      on_read(absl::InternalError("Socket is shutting down."));
     });
     return false;
   }
@@ -153,7 +154,7 @@ bool WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
   if (io_state_->socket->IsShutdown()) {
     io_state_->thread_pool->Run(
         [on_writable = std::move(on_writable)]() mutable {
-          on_writable(absl::UnavailableError("Socket is shutting down."));
+          on_writable(absl::InternalError("Socket is shutting down."));
         });
     return false;
   }
@@ -164,11 +165,11 @@ bool WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
               peer_address_string_.c_str(), str.length(), str.data());
     }
   }
-  GPR_ASSERT(data->Count() <= UINT_MAX);
+  CHECK(data->Count() <= UINT_MAX);
   absl::InlinedVector<WSABUF, kMaxWSABUFCount> buffers(data->Count());
   for (size_t i = 0; i < data->Count(); i++) {
     auto& slice = data->MutableSliceAt(i);
-    GPR_ASSERT(slice.size() <= ULONG_MAX);
+    CHECK(slice.size() <= ULONG_MAX);
     buffers[i].len = slice.size();
     buffers[i].buf = (char*)slice.begin();
   }
@@ -299,14 +300,14 @@ void WindowsEndpoint::HandleReadClosure::Run() {
       DumpSliceBuffer(buffer_, absl::StrFormat("WindowsEndpoint::%p READ",
                                                io_state->endpoint));
     }
-    status = absl::UnavailableError("End of TCP stream");
+    status = absl::InternalError("End of TCP stream");
     grpc_core::StatusSetInt(&status, grpc_core::StatusIntProperty::kRpcStatus,
                             GRPC_STATUS_UNAVAILABLE);
     buffer_->Swap(last_read_buffer_);
     return ResetAndReturnCallback()(status);
   }
-  GPR_DEBUG_ASSERT(result.bytes_transferred > 0);
-  GPR_DEBUG_ASSERT(result.bytes_transferred <= buffer_->Length());
+  DCHECK_GT(result.bytes_transferred, 0);
+  DCHECK(result.bytes_transferred <= buffer_->Length());
   buffer_->MoveFirstNBytesIntoSliceBuffer(result.bytes_transferred,
                                           last_read_buffer_);
   if (buffer_->Length() == 0) {
@@ -332,9 +333,9 @@ bool WindowsEndpoint::HandleReadClosure::MaybeFinishIfDataHasAlreadyBeenRead() {
 void WindowsEndpoint::HandleReadClosure::DonateSpareSlices(
     SliceBuffer* buffer) {
   // Donee buffer must be empty.
-  GPR_ASSERT(buffer->Length() == 0);
+  CHECK_EQ(buffer->Length(), 0);
   // HandleReadClosure must be in the reset state.
-  GPR_ASSERT(buffer_ == nullptr);
+  CHECK_EQ(buffer_, nullptr);
   buffer->Swap(last_read_buffer_);
 }
 
@@ -352,7 +353,7 @@ void WindowsEndpoint::HandleWriteClosure::Run() {
   if (result.wsa_error != 0) {
     status = GRPC_WSA_ERROR(result.wsa_error, "WSASend");
   } else {
-    GPR_ASSERT(result.bytes_transferred == buffer_->Length());
+    CHECK(result.bytes_transferred == buffer_->Length());
   }
   return ResetAndReturnCallback()(status);
 }