grpc 1.63.0 → 1.65.2

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"
 
@@ -41,8 +42,8 @@ constexpr int kMaxWSABUFCount = 16;
 void DumpSliceBuffer(SliceBuffer* buffer, absl::string_view context_string) {
   for (size_t i = 0; i < buffer->Count(); i++) {
     auto str = buffer->MutableSliceAt(i).as_string_view();
-    gpr_log(GPR_INFO, "%s: %.*s", context_string.data(), str.length(),
-            str.data());
+    GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+        << context_string << ": " << str;
   }
 }
 
@@ -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);
@@ -101,8 +102,7 @@ void WindowsEndpoint::AsyncIOState::DoTcpRead(SliceBuffer* buffer) {
   int wsa_error = status == 0 ? 0 : WSAGetLastError();
   if (wsa_error != WSAEWOULDBLOCK) {
     // Data or some error was returned immediately.
-    socket->read_info()->SetResult(
-        {/*wsa_error=*/wsa_error, /*bytes_read=*/bytes_read});
+    socket->read_info()->SetResult(wsa_error, bytes_read, "WSARecv");
     thread_pool->Run(&handle_read_event);
     return;
   }
@@ -119,9 +119,8 @@ void WindowsEndpoint::AsyncIOState::DoTcpRead(SliceBuffer* buffer) {
   if (wsa_error != 0 && wsa_error != WSA_IO_PENDING) {
     // The async read attempt returned an error immediately.
     socket->UnregisterReadCallback();
-    socket->read_info()->SetErrorStatus(GRPC_WSA_ERROR(
-        wsa_error,
-        absl::StrFormat("WindowsEndpont::%p Read failed", this).c_str()));
+    socket->read_info()->SetResult(
+        wsa_error, 0, absl::StrFormat("WindowsEndpont::%p Read failed", this));
     thread_pool->Run(&handle_read_event);
   }
 }
@@ -130,7 +129,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,22 +152,23 @@ 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;
   }
-  if (grpc_event_engine_endpoint_data_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(event_engine_endpoint_data)) {
     for (size_t i = 0; i < data->Count(); i++) {
       auto str = data->RefSlice(i).as_string_view();
-      gpr_log(GPR_INFO, "WindowsEndpoint::%p WRITE (peer=%s): %.*s", this,
-              peer_address_string_.c_str(), str.length(), str.data());
+      GRPC_TRACE_LOG(event_engine_endpoint, INFO)
+          << "WindowsEndpoint::" << this
+          << " WRITE (peer=" << peer_address_string_ << "): " << str;
     }
   }
-  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();
   }
@@ -219,8 +219,7 @@ bool WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
     int wsa_error = WSAGetLastError();
     if (wsa_error != WSA_IO_PENDING) {
       io_state_->socket->UnregisterWriteCallback();
-      io_state_->socket->write_info()->SetErrorStatus(
-          GRPC_WSA_ERROR(wsa_error, "WSASend"));
+      io_state_->socket->write_info()->SetResult(wsa_error, 0, "WSASend");
       io_state_->thread_pool->Run(&io_state_->handle_write_event);
     }
   }
@@ -295,18 +294,18 @@ void WindowsEndpoint::HandleReadClosure::Run() {
   }
   if (result.bytes_transferred == 0) {
     // Either the endpoint is shut down or we've seen the end of the stream
-    if (grpc_event_engine_endpoint_data_trace.enabled()) {
+    if (GRPC_TRACE_FLAG_ENABLED(event_engine_endpoint_data)) {
       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 +331,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 +351,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);
 }

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

@@ -16,7 +16,10 @@
 #ifdef GPR_WINDOWS
 
 #include <memory>
+#include <ostream>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
@@ -42,6 +45,7 @@
 #include "src/core/lib/event_engine/windows/windows_engine.h"
 #include "src/core/lib/event_engine/windows/windows_listener.h"
 #include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/gprpp/dump_args.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/error.h"
@@ -49,13 +53,104 @@
 namespace grpc_event_engine {
 namespace experimental {
 
-namespace {
-EventEngine::OnConnectCallback CreateCrashingOnConnectCallback() {
-  return [](absl::StatusOr<std::unique_ptr<EventEngine::Endpoint>>) {
-    grpc_core::Crash("Internal Error: OnConnect callback called when unset");
-  };
+std::ostream& operator<<(
+    std::ostream& out,
+    const WindowsEventEngine::ConnectionState& connection_state) {
+  out << "ConnectionState::" << &connection_state
+      << ": connection_state.address="
+      << ResolvedAddressToURI(connection_state.address_) << ","
+      << GRPC_DUMP_ARGS(connection_state.has_run_,
+                        connection_state.connection_handle_,
+                        connection_state.timer_handle_);
+  return out;
 }
-}  // namespace
+
+// ---- ConnectionState ----
+
+WindowsEventEngine::ConnectionState::ConnectionState(
+    std::shared_ptr<WindowsEventEngine> engine,
+    std::unique_ptr<WinSocket> socket, EventEngine::ResolvedAddress address,
+    MemoryAllocator allocator,
+    EventEngine::OnConnectCallback on_connect_user_callback)
+    : socket_(std::move(socket)),
+      address_(address),
+      allocator_(std::move(allocator)),
+      on_connect_user_callback_(std::move(on_connect_user_callback)),
+      engine_(std::move(engine)) {
+  CHECK(socket_ != nullptr);
+  connection_handle_ = ConnectionHandle{reinterpret_cast<intptr_t>(this),
+                                        engine_->aba_token_.fetch_add(1)};
+}
+
+void WindowsEventEngine::ConnectionState::Start(Duration timeout) {
+  on_connected_cb_ =
+      std::make_unique<OnConnectedCallback>(engine_.get(), shared_from_this());
+  socket_->NotifyOnWrite(on_connected_cb_.get());
+  deadline_timer_cb_ = std::make_unique<DeadlineTimerCallback>(
+      engine_.get(), shared_from_this());
+  timer_handle_ = engine_->RunAfter(timeout, deadline_timer_cb_.get());
+}
+
+EventEngine::OnConnectCallback
+WindowsEventEngine::ConnectionState::TakeCallback() {
+  return std::exchange(on_connect_user_callback_, nullptr);
+}
+
+std::unique_ptr<WindowsEndpoint>
+WindowsEventEngine::ConnectionState::FinishConnectingAndMakeEndpoint(
+    ThreadPool* thread_pool) {
+  ChannelArgsEndpointConfig cfg;
+  return std::make_unique<WindowsEndpoint>(address_, std::move(socket_),
+                                           std::move(allocator_), cfg,
+                                           thread_pool, engine_);
+}
+
+void WindowsEventEngine::ConnectionState::AbortOnConnect() {
+  on_connected_cb_.reset();
+}
+
+void WindowsEventEngine::ConnectionState::AbortDeadlineTimer() {
+  deadline_timer_cb_.reset();
+}
+
+void WindowsEventEngine::ConnectionState::OnConnectedCallback::Run() {
+  DCHECK_NE(connection_state_, nullptr)
+      << "ConnectionState::OnConnectedCallback::" << this
+      << " has already run. It should only ever run once.";
+  bool has_run;
+  {
+    grpc_core::MutexLock lock(&connection_state_->mu_);
+    has_run = std::exchange(connection_state_->has_run_, true);
+  }
+  // This could race with the deadline timer. If so, the engine's
+  // OnConnectCompleted callback should not run, and the refs should be
+  // released.
+  if (has_run) {
+    connection_state_.reset();
+    return;
+  }
+  engine_->OnConnectCompleted(std::move(connection_state_));
+}
+
+void WindowsEventEngine::ConnectionState::DeadlineTimerCallback::Run() {
+  DCHECK_NE(connection_state_, nullptr)
+      << "ConnectionState::DeadlineTimerCallback::" << this
+      << " has already run. It should only ever run once.";
+  bool has_run;
+  {
+    grpc_core::MutexLock lock(&connection_state_->mu_);
+    has_run = std::exchange(connection_state_->has_run_, true);
+  }
+  // This could race with the on connected callback. If so, the engine's
+  // OnDeadlineTimerFired callback should not run, and the refs should be
+  // released.
+  if (has_run) {
+    connection_state_.reset();
+    return;
+  }
+  engine_->OnDeadlineTimerFired(std::move(connection_state_));
+}
+
 // ---- IOCPWorkClosure ----
 
 WindowsEventEngine::IOCPWorkClosure::IOCPWorkClosure(ThreadPool* thread_pool,
@@ -65,6 +160,7 @@ WindowsEventEngine::IOCPWorkClosure::IOCPWorkClosure(ThreadPool* thread_pool,
 }
 
 void WindowsEventEngine::IOCPWorkClosure::Run() {
+  if (done_signal_.HasBeenNotified()) return;
   auto result = iocp_->Work(std::chrono::seconds(60), [this] {
     workers_.fetch_add(1);
     thread_pool_->Run(this);
@@ -114,7 +210,7 @@ WindowsEventEngine::WindowsEventEngine()
       iocp_worker_(thread_pool_.get(), &iocp_) {
   WSADATA wsaData;
   int status = WSAStartup(MAKEWORD(2, 0), &wsaData);
-  GPR_ASSERT(status == 0);
+  CHECK_EQ(status, 0);
 }
 
 WindowsEventEngine::~WindowsEventEngine() {
@@ -122,7 +218,7 @@ WindowsEventEngine::~WindowsEventEngine() {
   {
     task_mu_.Lock();
     if (!known_handles_.empty()) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
+      if (GRPC_TRACE_FLAG_ENABLED(event_engine)) {
         for (auto handle : known_handles_) {
           gpr_log(GPR_ERROR,
                   "WindowsEventEngine:%p uncleared TaskHandle at shutdown:%s",
@@ -134,7 +230,7 @@ WindowsEventEngine::~WindowsEventEngine() {
       auto deadline =
           timer_manager_.Now() + grpc_core::Duration::FromSecondsAsDouble(10);
       while (!known_handles_.empty() && timer_manager_.Now() < deadline) {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
+        if (GRPC_TRACE_FLAG_ENABLED(event_engine)) {
           GRPC_LOG_EVERY_N_SEC(1, GPR_DEBUG, "Waiting for timers. %d remaining",
                                known_handles_.size());
         }
@@ -143,13 +239,13 @@ WindowsEventEngine::~WindowsEventEngine() {
         task_mu_.Lock();
       }
     }
-    GPR_ASSERT(GPR_LIKELY(known_handles_.empty()));
+    CHECK(GPR_LIKELY(known_handles_.empty()));
     task_mu_.Unlock();
   }
   iocp_.Kick();
   iocp_worker_.WaitForShutdown();
   iocp_.Shutdown();
-  GPR_ASSERT(WSACleanup() == 0);
+  CHECK_EQ(WSACleanup(), 0);
   timer_manager_.Shutdown();
   thread_pool_->Quiesce();
 }
@@ -241,8 +337,8 @@ WindowsEventEngine::GetDNSResolver(
   return std::make_unique<WindowsEventEngine::WindowsDNSResolver>(
       std::move(*ares_resolver));
 #else   // GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
-  GRPC_EVENT_ENGINE_DNS_TRACE(
-      "WindowsEventEngine:%p creating NativeWindowsDNSResolver", this);
+  GRPC_TRACE_LOG(event_engine_dns, INFO)
+      << "WindowsEventEngine::" << this << " creating NativeWindowsDNSResolver";
   return std::make_unique<NativeWindowsDNSResolver>(shared_from_this());
 #endif  // GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
 }
@@ -255,35 +351,54 @@ void WindowsEventEngine::OnConnectCompleted(
   EventEngine::OnConnectCallback cb;
   {
     // Connection attempt complete!
-    grpc_core::MutexLock lock(&state->mu);
-    cb = std::move(state->on_connected_user_callback);
-    state->on_connected_user_callback = CreateCrashingOnConnectCallback();
-    state->on_connected = nullptr;
+    grpc_core::MutexLock lock(&state->mu());
+    // return early if we cannot cancel the connection timeout timer.
+    int erased_handles = 0;
     {
       grpc_core::MutexLock handle_lock(&connection_mu_);
-      known_connection_handles_.erase(state->connection_handle);
+      erased_handles =
+          known_connection_handles_.erase(state->connection_handle());
     }
-    const auto& overlapped_result = state->socket->write_info()->result();
-    // return early if we cannot cancel the connection timeout timer.
-    if (!Cancel(state->timer_handle)) return;
+    if (erased_handles != 1 || !Cancel(state->timer_handle())) {
+      GRPC_EVENT_ENGINE_TRACE(
+          "%s", "Not accepting connection since the deadline timer has fired");
+      return;
+    }
+    // Release refs held by the deadline timer.
+    state->AbortDeadlineTimer();
+    const auto& overlapped_result = state->socket()->write_info()->result();
     if (!overlapped_result.error_status.ok()) {
-      state->socket->Shutdown(DEBUG_LOCATION, "ConnectEx failure");
+      state->socket()->Shutdown(DEBUG_LOCATION, "ConnectEx failure");
       endpoint = overlapped_result.error_status;
     } else if (overlapped_result.wsa_error != 0) {
-      state->socket->Shutdown(DEBUG_LOCATION, "ConnectEx failure");
+      state->socket()->Shutdown(DEBUG_LOCATION, "ConnectEx failure");
       endpoint = GRPC_WSA_ERROR(overlapped_result.wsa_error, "ConnectEx");
     } else {
-      ChannelArgsEndpointConfig cfg;
-      endpoint = std::make_unique<WindowsEndpoint>(
-          state->address, std::move(state->socket), std::move(state->allocator),
-          cfg, thread_pool_.get(), shared_from_this());
+      endpoint = state->FinishConnectingAndMakeEndpoint(thread_pool_.get());
     }
+    cb = state->TakeCallback();
   }
   // This code should be running in a thread pool thread already, so the
   // callback can be run directly.
+  state.reset();
   cb(std::move(endpoint));
 }
 
+void WindowsEventEngine::OnDeadlineTimerFired(
+    std::shared_ptr<ConnectionState> connection_state) {
+  bool cancelled = false;
+  EventEngine::OnConnectCallback cb;
+  {
+    grpc_core::MutexLock lock(&connection_state->mu());
+    cancelled = CancelConnectFromDeadlineTimer(connection_state.get());
+    if (cancelled) cb = connection_state->TakeCallback();
+  }
+  if (cancelled) {
+    connection_state.reset();
+    cb(absl::DeadlineExceededError("Connection timed out"));
+  }
+}
+
 EventEngine::ConnectionHandle WindowsEventEngine::Connect(
     OnConnectCallback on_connect, const ResolvedAddress& addr,
     const EndpointConfig& /* args */, MemoryAllocator memory_allocator,
@@ -366,65 +481,61 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
     return EventEngine::ConnectionHandle::kInvalid;
   }
   // Prepare the socket to receive a connection
-  auto connection_state = std::make_shared<ConnectionState>();
-  grpc_core::MutexLock lock(&connection_state->mu);
-  connection_state->socket = iocp_.Watch(sock);
-  GPR_ASSERT(connection_state->socket != nullptr);
-  auto* info = connection_state->socket->write_info();
-  connection_state->address = address;
-  connection_state->allocator = std::move(memory_allocator);
-  connection_state->on_connected_user_callback = std::move(on_connect);
-  connection_state->on_connected =
-      SelfDeletingClosure::Create([this, connection_state]() mutable {
-        OnConnectCompleted(std::move(connection_state));
-      });
-  connection_state->timer_handle =
-      RunAfter(timeout, [this, connection_state]() {
-        grpc_core::ReleasableMutexLock lock(&connection_state->mu);
-        if (CancelConnectFromDeadlineTimer(connection_state.get())) {
-          auto cb = std::move(connection_state->on_connected_user_callback);
-          connection_state->on_connected_user_callback =
-              CreateCrashingOnConnectCallback();
-          lock.Release();
-          cb(absl::DeadlineExceededError("Connection timed out"));
-        }
-        // else: The connection attempt could not be canceled. We can assume
-        // the connection callback will be called.
-      });
-  // Connect
-  connection_state->socket->NotifyOnWrite(connection_state->on_connected);
+  auto connection_state = std::make_shared<ConnectionState>(
+      std::static_pointer_cast<WindowsEventEngine>(shared_from_this()),
+      /*socket=*/iocp_.Watch(sock), address,
+      /*memory_allocator=*/std::move(memory_allocator),
+      /*on_connect_user_callback=*/std::move(on_connect));
+  grpc_core::MutexLock lock(&connection_state->mu());
+  auto* info = connection_state->socket()->write_info();
+  {
+    grpc_core::MutexLock connection_handle_lock(&connection_mu_);
+    known_connection_handles_.insert(connection_state->connection_handle());
+  }
+  connection_state->Start(timeout);
   bool success =
-      ConnectEx(connection_state->socket->raw_socket(), address.address(),
+      ConnectEx(connection_state->socket()->raw_socket(), address.address(),
                 address.size(), nullptr, 0, nullptr, info->overlapped());
   // It wouldn't be unusual to get a success immediately. But we'll still get an
   // IOCP notification, so let's ignore it.
-  if (!success) {
-    int last_error = WSAGetLastError();
-    if (last_error != ERROR_IO_PENDING) {
-      if (!Cancel(connection_state->timer_handle)) {
-        return EventEngine::ConnectionHandle::kInvalid;
-      }
-      connection_state->socket->Shutdown(DEBUG_LOCATION, "ConnectEx");
-      Run([connection_state = std::move(connection_state),
-           status = GRPC_WSA_ERROR(WSAGetLastError(), "ConnectEx")]() mutable {
-        EventEngine::OnConnectCallback cb;
-        {
-          grpc_core::MutexLock lock(&connection_state->mu);
-          cb = std::move(connection_state->on_connected_user_callback);
-          connection_state->on_connected_user_callback =
-              CreateCrashingOnConnectCallback();
-        }
-        cb(status);
-      });
-      return EventEngine::ConnectionHandle::kInvalid;
-    }
+  if (success) return connection_state->connection_handle();
+  // Otherwise, we need to handle an error or a pending IO Event.
+  int last_error = WSAGetLastError();
+  if (last_error == ERROR_IO_PENDING) {
+    // Overlapped I/O operation is in progress.
+    return connection_state->connection_handle();
+  }
+  // Time to abort the connection.
+  // The on-connect callback won't run, so we must clean up its state.
+  connection_state->AbortOnConnect();
+  int erased_handles = 0;
+  {
+    grpc_core::MutexLock connection_handle_lock(&connection_mu_);
+    erased_handles =
+        known_connection_handles_.erase(connection_state->connection_handle());
+  }
+  CHECK_EQ(erased_handles, 1) << "Did not find connection handle "
+                              << connection_state->connection_handle()
+                              << " after a synchronous connection failure. "
+                                 "This should not be possible.";
+  connection_state->socket()->Shutdown(DEBUG_LOCATION, "ConnectEx");
+  if (!Cancel(connection_state->timer_handle())) {
+    // The deadline timer will run, or is running.
+    return EventEngine::ConnectionHandle::kInvalid;
   }
-  connection_state->connection_handle =
-      ConnectionHandle{reinterpret_cast<intptr_t>(connection_state.get()),
-                       aba_token_.fetch_add(1)};
-  grpc_core::MutexLock connection_handle_lock(&connection_mu_);
-  known_connection_handles_.insert(connection_state->connection_handle);
-  return connection_state->connection_handle;
+  // The deadline timer won't run, so we must clean up its state.
+  connection_state->AbortDeadlineTimer();
+  Run([connection_state = std::move(connection_state),
+       status = GRPC_WSA_ERROR(WSAGetLastError(), "ConnectEx")]() mutable {
+    EventEngine::OnConnectCallback cb;
+    {
+      grpc_core::MutexLock lock(&connection_state->mu());
+      cb = connection_state->TakeCallback();
+    }
+    connection_state.reset();
+    cb(std::move(status));
+  });
+  return EventEngine::ConnectionHandle::kInvalid;
 }
 
 bool WindowsEventEngine::CancelConnect(EventEngine::ConnectionHandle handle) {
@@ -436,17 +547,20 @@ bool WindowsEventEngine::CancelConnect(EventEngine::ConnectionHandle handle) {
   // Erase the connection handle, which may be unknown
   {
     grpc_core::MutexLock lock(&connection_mu_);
-    if (!known_connection_handles_.contains(handle)) {
+    if (known_connection_handles_.erase(handle) != 1) {
       GRPC_EVENT_ENGINE_TRACE(
           "Unknown connection handle: %s",
           HandleToString<EventEngine::ConnectionHandle>(handle).c_str());
       return false;
     }
-    known_connection_handles_.erase(handle);
   }
   auto* connection_state = reinterpret_cast<ConnectionState*>(handle.keys[0]);
-  grpc_core::MutexLock state_lock(&connection_state->mu);
-  if (!Cancel(connection_state->timer_handle)) return false;
+  grpc_core::MutexLock state_lock(&connection_state->mu());
+  // The connection cannot be cancelled if the deadline timer is already firing.
+  if (!Cancel(connection_state->timer_handle())) return false;
+  // The deadline timer was cancelled, so we must clean up its state.
+  connection_state->AbortDeadlineTimer();
+  // The on-connect callback will run when the socket shutdown event occurs.
   return CancelConnectInternalStateLocked(connection_state);
 }
 
@@ -455,20 +569,21 @@ bool WindowsEventEngine::CancelConnectFromDeadlineTimer(
   // Erase the connection handle, which is guaranteed to exist.
   {
     grpc_core::MutexLock lock(&connection_mu_);
-    GPR_ASSERT(known_connection_handles_.erase(
-                   connection_state->connection_handle) == 1);
+    if (known_connection_handles_.erase(
+            connection_state->connection_handle()) != 1) {
+      return false;
+    }
   }
   return CancelConnectInternalStateLocked(connection_state);
 }
 
 bool WindowsEventEngine::CancelConnectInternalStateLocked(
     ConnectionState* connection_state) {
-  connection_state->socket->Shutdown(DEBUG_LOCATION, "CancelConnect");
+  connection_state->socket()->Shutdown(DEBUG_LOCATION, "CancelConnect");
   // Release the connection_state shared_ptr owned by the connected callback.
-  delete connection_state->on_connected;
   GRPC_EVENT_ENGINE_TRACE("Successfully cancelled connection %s",
                           HandleToString<EventEngine::ConnectionHandle>(
-                              connection_state->connection_handle)
+                              connection_state->connection_handle())
                               .c_str());
   return true;
 }