diff --git a/build/source_list.bzl b/build/source_list.bzl
index fd20c48..de04f82 100644
--- a/build/source_list.bzl
+++ b/build/source_list.bzl
@@ -665,6 +665,7 @@
     "quic/core/quic_trace_visitor.cc",
     "quic/core/quic_transmission_info.cc",
     "quic/core/quic_types.cc",
+    "quic/core/quic_udp_socket.cc",
     "quic/core/quic_unacked_packet_map.cc",
     "quic/core/quic_utils.cc",
     "quic/core/quic_version_manager.cc",
@@ -991,7 +992,6 @@
     "quic/core/quic_default_packet_writer.cc",
     "quic/core/quic_packet_reader.cc",
     "quic/core/quic_syscall_wrapper.cc",
-    "quic/core/quic_udp_socket_posix.cc",
     "quic/masque/masque_client.cc",
     "quic/masque/masque_client_session.cc",
     "quic/masque/masque_client_tools.cc",
diff --git a/build/source_list.gni b/build/source_list.gni
index 4d34746..ac54fca 100644
--- a/build/source_list.gni
+++ b/build/source_list.gni
@@ -665,6 +665,7 @@
     "src/quiche/quic/core/quic_trace_visitor.cc",
     "src/quiche/quic/core/quic_transmission_info.cc",
     "src/quiche/quic/core/quic_types.cc",
+    "src/quiche/quic/core/quic_udp_socket.cc",
     "src/quiche/quic/core/quic_unacked_packet_map.cc",
     "src/quiche/quic/core/quic_utils.cc",
     "src/quiche/quic/core/quic_version_manager.cc",
@@ -991,7 +992,6 @@
     "src/quiche/quic/core/quic_default_packet_writer.cc",
     "src/quiche/quic/core/quic_packet_reader.cc",
     "src/quiche/quic/core/quic_syscall_wrapper.cc",
-    "src/quiche/quic/core/quic_udp_socket_posix.cc",
     "src/quiche/quic/masque/masque_client.cc",
     "src/quiche/quic/masque/masque_client_session.cc",
     "src/quiche/quic/masque/masque_client_tools.cc",
diff --git a/build/source_list.json b/build/source_list.json
index d9867f7..4465eeb 100644
--- a/build/source_list.json
+++ b/build/source_list.json
@@ -664,6 +664,7 @@
     "quiche/quic/core/quic_trace_visitor.cc",
     "quiche/quic/core/quic_transmission_info.cc",
     "quiche/quic/core/quic_types.cc",
+    "quiche/quic/core/quic_udp_socket.cc",
     "quiche/quic/core/quic_unacked_packet_map.cc",
     "quiche/quic/core/quic_utils.cc",
     "quiche/quic/core/quic_version_manager.cc",
@@ -990,7 +991,6 @@
     "quiche/quic/core/quic_default_packet_writer.cc",
     "quiche/quic/core/quic_packet_reader.cc",
     "quiche/quic/core/quic_syscall_wrapper.cc",
-    "quiche/quic/core/quic_udp_socket_posix.cc",
     "quiche/quic/masque/masque_client.cc",
     "quiche/quic/masque/masque_client_session.cc",
     "quiche/quic/masque/masque_client_tools.cc",
diff --git a/quiche/quic/core/io/socket.h b/quiche/quic/core/io/socket.h
index d428f8c..8fc7732 100644
--- a/quiche/quic/core/io/socket.h
+++ b/quiche/quic/core/io/socket.h
@@ -28,9 +28,11 @@
 #if defined(_WIN32)
 using SocketFd = SOCKET;
 inline constexpr SocketFd kInvalidSocketFd = INVALID_SOCKET;
+inline constexpr int kSocketErrorMsgSize = WSAEMSGSIZE;
 #else
 using SocketFd = int;
 inline constexpr SocketFd kInvalidSocketFd = -1;
+inline constexpr int kSocketErrorMsgSize = EMSGSIZE;
 #endif
 
 // Low-level platform-agnostic socket operations. Closely follows the behavior
diff --git a/quiche/quic/core/quic_default_packet_writer.cc b/quiche/quic/core/quic_default_packet_writer.cc
index 78feee5..7eac827 100644
--- a/quiche/quic/core/quic_default_packet_writer.cc
+++ b/quiche/quic/core/quic_default_packet_writer.cc
@@ -8,7 +8,7 @@
 
 namespace quic {
 
-QuicDefaultPacketWriter::QuicDefaultPacketWriter(int fd)
+QuicDefaultPacketWriter::QuicDefaultPacketWriter(SocketFd fd)
     : fd_(fd), write_blocked_(false) {}
 
 QuicDefaultPacketWriter::~QuicDefaultPacketWriter() = default;
@@ -36,7 +36,7 @@
 void QuicDefaultPacketWriter::SetWritable() { write_blocked_ = false; }
 
 absl::optional<int> QuicDefaultPacketWriter::MessageTooBigErrorCode() const {
-  return EMSGSIZE;
+  return kSocketErrorMsgSize;
 }
 
 QuicByteCount QuicDefaultPacketWriter::GetMaxPacketSize(
diff --git a/quiche/quic/core/quic_default_packet_writer.h b/quiche/quic/core/quic_default_packet_writer.h
index b2a0a86..718f8eb 100644
--- a/quiche/quic/core/quic_default_packet_writer.h
+++ b/quiche/quic/core/quic_default_packet_writer.h
@@ -7,6 +7,7 @@
 
 #include <cstddef>
 
+#include "quiche/quic/core/io/socket.h"
 #include "quiche/quic/core/quic_packet_writer.h"
 #include "quiche/quic/platform/api/quic_export.h"
 #include "quiche/quic/platform/api/quic_socket_address.h"
@@ -18,7 +19,7 @@
 // Default packet writer which wraps QuicSocketUtils WritePacket.
 class QUIC_EXPORT_PRIVATE QuicDefaultPacketWriter : public QuicPacketWriter {
  public:
-  explicit QuicDefaultPacketWriter(int fd);
+  explicit QuicDefaultPacketWriter(SocketFd fd);
   QuicDefaultPacketWriter(const QuicDefaultPacketWriter&) = delete;
   QuicDefaultPacketWriter& operator=(const QuicDefaultPacketWriter&) = delete;
   ~QuicDefaultPacketWriter() override;
@@ -40,14 +41,14 @@
       const QuicSocketAddress& peer_address) override;
   WriteResult Flush() override;
 
-  void set_fd(int fd) { fd_ = fd; }
+  void set_fd(SocketFd fd) { fd_ = fd; }
 
  protected:
   void set_write_blocked(bool is_blocked);
-  int fd() { return fd_; }
+  SocketFd fd() { return fd_; }
 
  private:
-  int fd_;
+  SocketFd fd_;
   bool write_blocked_;
 };
 
diff --git a/quiche/quic/core/quic_udp_socket.cc b/quiche/quic/core/quic_udp_socket.cc
new file mode 100644
index 0000000..1a35b72
--- /dev/null
+++ b/quiche/quic/core/quic_udp_socket.cc
@@ -0,0 +1,205 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#if defined(__APPLE__) && !defined(__APPLE_USE_RFC_3542)
+// This must be defined before including any system headers.
+#define __APPLE_USE_RFC_3542
+#endif  // defined(__APPLE__) && !defined(__APPLE_USE_RFC_3542)
+
+#include "absl/base/optimization.h"
+#include "quiche/quic/core/io/socket.h"
+#include "quiche/quic/core/quic_udp_socket.h"
+#include "quiche/quic/platform/api/quic_bug_tracker.h"
+#include "quiche/quic/platform/api/quic_flag_utils.h"
+
+// Common cmsg-related functions are defined below.
+// Windows and POSIX cmsg formats are actually fairly similar, except the
+// Windows ones have all of the macros prefixed with WSA_ and all the type names
+// are different.
+
+namespace quic {
+namespace {
+
+#if defined(_WIN32)
+using PlatformCmsghdr = ::WSACMSGHDR;
+#if !defined(CMSG_DATA)
+#define CMSG_DATA WSA_CMSG_DATA
+#endif  // !defined(CMSG_DATA)
+#else
+using PlatformCmsghdr = ::cmsghdr;
+#endif  // defined(_WIN32)
+
+void PopulatePacketInfoFromControlMessageBase(
+    PlatformCmsghdr* cmsg, QuicUdpPacketInfo* packet_info,
+    BitMask64 packet_info_interested) {
+  if (cmsg->cmsg_level == IPPROTO_IPV6 && cmsg->cmsg_type == IPV6_PKTINFO) {
+    if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::V6_SELF_IP)) {
+      const in6_pktinfo* info = reinterpret_cast<in6_pktinfo*>(CMSG_DATA(cmsg));
+      const char* addr_data = reinterpret_cast<const char*>(&info->ipi6_addr);
+      int addr_len = sizeof(in6_addr);
+      QuicIpAddress self_v6_ip;
+      if (self_v6_ip.FromPackedString(addr_data, addr_len)) {
+        packet_info->SetSelfV6Ip(self_v6_ip);
+      } else {
+        QUIC_BUG(quic_bug_10751_1) << "QuicIpAddress::FromPackedString failed";
+      }
+    }
+    return;
+  }
+
+  if (cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_PKTINFO) {
+    if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::V4_SELF_IP)) {
+      const in_pktinfo* info = reinterpret_cast<in_pktinfo*>(CMSG_DATA(cmsg));
+      const char* addr_data = reinterpret_cast<const char*>(&info->ipi_addr);
+      int addr_len = sizeof(in_addr);
+      QuicIpAddress self_v4_ip;
+      if (self_v4_ip.FromPackedString(addr_data, addr_len)) {
+        packet_info->SetSelfV4Ip(self_v4_ip);
+      } else {
+        QUIC_BUG(quic_bug_10751_2) << "QuicIpAddress::FromPackedString failed";
+      }
+    }
+    return;
+  }
+}
+
+}  // namespace
+}  // namespace quic
+
+#if defined(_WIN32)
+#include "quiche/quic/core/quic_udp_socket_win.inc"
+#else
+#include "quiche/quic/core/quic_udp_socket_posix.inc"
+#endif
+
+namespace quic {
+
+QuicUdpSocketFd QuicUdpSocketApi::Create(int address_family,
+                                         int receive_buffer_size,
+                                         int send_buffer_size, bool ipv6_only) {
+  // QUICHE_DCHECK here so the program exits early(before reading packets) in
+  // debug mode. This should have been a static_assert, however it can't be done
+  // on ios/osx because CMSG_SPACE isn't a constant expression there.
+  QUICHE_DCHECK_GE(kDefaultUdpPacketControlBufferSize, kMinCmsgSpaceForRead);
+
+  absl::StatusOr<SocketFd> socket = socket_api::CreateSocket(
+      quiche::FromPlatformAddressFamily(address_family),
+      socket_api::SocketProtocol::kUdp,
+      /*blocking=*/false);
+
+  if (!socket.ok()) {
+    QUIC_LOG_FIRST_N(ERROR, 100)
+        << "UDP non-blocking socket creation for address_family="
+        << address_family << " failed: " << socket.status();
+    return kQuicInvalidSocketFd;
+  }
+
+#if !defined(_WIN32)
+  SetGoogleSocketOptions(socket.value());
+#endif
+
+  if (!SetupSocket(socket.value(), address_family, receive_buffer_size,
+                   send_buffer_size, ipv6_only)) {
+    Destroy(socket.value());
+    return kQuicInvalidSocketFd;
+  }
+
+  return socket.value();
+}
+
+void QuicUdpSocketApi::Destroy(QuicUdpSocketFd fd) {
+  if (fd != kQuicInvalidSocketFd) {
+    absl::Status result = socket_api::Close(fd);
+    if (!result.ok()) {
+      QUIC_LOG_FIRST_N(WARNING, 100)
+          << "Failed to close UDP socket with error " << result;
+    }
+  }
+}
+
+bool QuicUdpSocketApi::Bind(QuicUdpSocketFd fd, QuicSocketAddress address) {
+  sockaddr_storage addr = address.generic_address();
+  int addr_len =
+      address.host().IsIPv4() ? sizeof(sockaddr_in) : sizeof(sockaddr_in6);
+  return 0 == bind(fd, reinterpret_cast<sockaddr*>(&addr), addr_len);
+}
+
+bool QuicUdpSocketApi::BindInterface(QuicUdpSocketFd fd,
+                                     const std::string& interface_name) {
+#if defined(__linux__) && !defined(__ANDROID_API__)
+  if (interface_name.empty() || interface_name.size() >= IFNAMSIZ) {
+    QUIC_BUG(udp_bad_interface_name)
+        << "interface_name must be nonempty and shorter than " << IFNAMSIZ;
+    return false;
+  }
+
+  return 0 == setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE,
+                         interface_name.c_str(), interface_name.length());
+#else
+  (void)fd;
+  (void)interface_name;
+  QUIC_BUG(interface_bind_not_implemented)
+      << "Interface binding is not implemented on this platform";
+  return false;
+#endif
+}
+
+bool QuicUdpSocketApi::EnableDroppedPacketCount(QuicUdpSocketFd fd) {
+#if defined(__linux__) && defined(SO_RXQ_OVFL)
+  int get_overflow = 1;
+  return 0 == setsockopt(fd, SOL_SOCKET, SO_RXQ_OVFL, &get_overflow,
+                         sizeof(get_overflow));
+#else
+  (void)fd;
+  return false;
+#endif
+}
+
+bool QuicUdpSocketApi::EnableReceiveSelfIpAddressForV4(QuicUdpSocketFd fd) {
+  int get_self_ip = 1;
+  return 0 == setsockopt(fd, IPPROTO_IP, IP_PKTINFO,
+                         reinterpret_cast<char*>(&get_self_ip),
+                         sizeof(get_self_ip));
+}
+
+bool QuicUdpSocketApi::EnableReceiveSelfIpAddressForV6(QuicUdpSocketFd fd) {
+  int get_self_ip = 1;
+  return 0 == setsockopt(fd, IPPROTO_IPV6, kIpv6RecvPacketInfo,
+                         reinterpret_cast<char*>(&get_self_ip),
+                         sizeof(get_self_ip));
+}
+
+bool QuicUdpSocketApi::EnableReceiveTimestamp(QuicUdpSocketFd fd) {
+#if defined(__linux__) && (!defined(__ANDROID_API__) || __ANDROID_API__ >= 21)
+  int timestamping = SOF_TIMESTAMPING_RX_SOFTWARE | SOF_TIMESTAMPING_SOFTWARE;
+  return 0 == setsockopt(fd, SOL_SOCKET, SO_TIMESTAMPING, &timestamping,
+                         sizeof(timestamping));
+#else
+  (void)fd;
+  return false;
+#endif
+}
+
+bool QuicUdpSocketApi::EnableReceiveTtlForV4(QuicUdpSocketFd fd) {
+#if defined(QUIC_UDP_SOCKET_SUPPORT_TTL)
+  int get_ttl = 1;
+  return 0 == setsockopt(fd, IPPROTO_IP, IP_RECVTTL, &get_ttl, sizeof(get_ttl));
+#else
+  (void)fd;
+  return false;
+#endif
+}
+
+bool QuicUdpSocketApi::EnableReceiveTtlForV6(QuicUdpSocketFd fd) {
+#if defined(QUIC_UDP_SOCKET_SUPPORT_TTL)
+  int get_ttl = 1;
+  return 0 == setsockopt(fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &get_ttl,
+                         sizeof(get_ttl));
+#else
+  (void)fd;
+  return false;
+#endif
+}
+
+}  // namespace quic
diff --git a/quiche/quic/core/quic_udp_socket_posix.cc b/quiche/quic/core/quic_udp_socket_posix.inc
similarity index 77%
rename from quiche/quic/core/quic_udp_socket_posix.cc
rename to quiche/quic/core/quic_udp_socket_posix.inc
index 26d4ef4..deb406c 100644
--- a/quiche/quic/core/quic_udp_socket_posix.cc
+++ b/quiche/quic/core/quic_udp_socket_posix.inc
@@ -2,12 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "quiche/quic/core/quic_types.h"
-#if defined(__APPLE__) && !defined(__APPLE_USE_RFC_3542)
-// This must be defined before including any system headers.
-#define __APPLE_USE_RFC_3542
-#endif  // defined(__APPLE__) && !defined(__APPLE_USE_RFC_3542)
-
 #include <arpa/inet.h>
 #include <fcntl.h>
 #include <net/if.h>
@@ -43,6 +37,8 @@
 // Explicit Congestion Notification is the last two bits of the TOS byte.
 constexpr uint8_t kEcnMask = 0x03;
 
+constexpr int kIpv6RecvPacketInfo = IPV6_RECVPKTINFO;
+
 #if defined(__linux__) && (!defined(__ANDROID_API__) || __ANDROID_API__ >= 21)
 #define QUIC_UDP_SOCKET_SUPPORT_LINUX_TIMESTAMPING 1
 // This is the structure that SO_TIMESTAMPING fills into the cmsg header.
@@ -125,35 +121,8 @@
   }
 #endif
 
-  if (cmsg->cmsg_level == IPPROTO_IPV6 && cmsg->cmsg_type == IPV6_PKTINFO) {
-    if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::V6_SELF_IP)) {
-      const in6_pktinfo* info = reinterpret_cast<in6_pktinfo*>(CMSG_DATA(cmsg));
-      const char* addr_data = reinterpret_cast<const char*>(&info->ipi6_addr);
-      int addr_len = sizeof(in6_addr);
-      QuicIpAddress self_v6_ip;
-      if (self_v6_ip.FromPackedString(addr_data, addr_len)) {
-        packet_info->SetSelfV6Ip(self_v6_ip);
-      } else {
-        QUIC_BUG(quic_bug_10751_1) << "QuicIpAddress::FromPackedString failed";
-      }
-    }
-    return;
-  }
-
-  if (cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_PKTINFO) {
-    if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::V4_SELF_IP)) {
-      const in_pktinfo* info = reinterpret_cast<in_pktinfo*>(CMSG_DATA(cmsg));
-      const char* addr_data = reinterpret_cast<const char*>(&info->ipi_addr);
-      int addr_len = sizeof(in_addr);
-      QuicIpAddress self_v4_ip;
-      if (self_v4_ip.FromPackedString(addr_data, addr_len)) {
-        packet_info->SetSelfV4Ip(self_v4_ip);
-      } else {
-        QUIC_BUG(quic_bug_10751_2) << "QuicIpAddress::FromPackedString failed";
-      }
-    }
-    return;
-  }
+  PopulatePacketInfoFromControlMessageBase(cmsg, packet_info,
+                                           packet_info_interested);
 
   if ((cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_TTL) ||
       (cmsg->cmsg_level == IPPROTO_IPV6 && cmsg->cmsg_type == IPV6_HOPLIMIT)) {
@@ -214,37 +183,6 @@
 }
 }  // namespace
 
-QuicUdpSocketFd QuicUdpSocketApi::Create(int address_family,
-                                         int receive_buffer_size,
-                                         int send_buffer_size, bool ipv6_only) {
-  // QUICHE_DCHECK here so the program exits early(before reading packets) in
-  // debug mode. This should have been a static_assert, however it can't be done
-  // on ios/osx because CMSG_SPACE isn't a constant expression there.
-  QUICHE_DCHECK_GE(kDefaultUdpPacketControlBufferSize, kMinCmsgSpaceForRead);
-
-  absl::StatusOr<SocketFd> socket = socket_api::CreateSocket(
-      quiche::FromPlatformAddressFamily(address_family),
-      socket_api::SocketProtocol::kUdp,
-      /*blocking=*/false);
-
-  if (!socket.ok()) {
-    QUIC_LOG_FIRST_N(ERROR, 100)
-        << "UDP non-blocking socket creation for address_family="
-        << address_family << " failed: " << socket.status();
-    return kQuicInvalidSocketFd;
-  }
-
-  SetGoogleSocketOptions(socket.value());
-
-  if (!SetupSocket(socket.value(), address_family, receive_buffer_size,
-                   send_buffer_size, ipv6_only)) {
-    Destroy(socket.value());
-    return kQuicInvalidSocketFd;
-  }
-
-  return socket.value();
-}
-
 bool QuicUdpSocketApi::SetupSocket(QuicUdpSocketFd fd, int address_family,
                                    int receive_buffer_size,
                                    int send_buffer_size, bool ipv6_only) {
@@ -298,98 +236,6 @@
   return true;
 }
 
-void QuicUdpSocketApi::Destroy(QuicUdpSocketFd fd) {
-  if (fd != kQuicInvalidSocketFd) {
-    absl::Status result = socket_api::Close(fd);
-    if (!result.ok()) {
-      QUIC_LOG_FIRST_N(WARNING, 100)
-          << "Failed to close UDP socket with error " << result;
-    }
-  }
-}
-
-bool QuicUdpSocketApi::Bind(QuicUdpSocketFd fd, QuicSocketAddress address) {
-  sockaddr_storage addr = address.generic_address();
-  int addr_len =
-      address.host().IsIPv4() ? sizeof(sockaddr_in) : sizeof(sockaddr_in6);
-  return 0 == bind(fd, reinterpret_cast<sockaddr*>(&addr), addr_len);
-}
-
-bool QuicUdpSocketApi::BindInterface(QuicUdpSocketFd fd,
-                                     const std::string& interface_name) {
-#if defined(__linux__) && !defined(__ANDROID_API__)
-  if (interface_name.empty() || interface_name.size() >= IFNAMSIZ) {
-    QUIC_BUG(udp_bad_interface_name)
-        << "interface_name must be nonempty and shorter than " << IFNAMSIZ;
-    return false;
-  }
-
-  return 0 == setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE,
-                         interface_name.c_str(), interface_name.length());
-#else
-  (void)fd;
-  (void)interface_name;
-  QUIC_BUG(interface_bind_not_implemented)
-      << "Interface binding is not implemented on this platform";
-  return false;
-#endif
-}
-
-bool QuicUdpSocketApi::EnableDroppedPacketCount(QuicUdpSocketFd fd) {
-#if defined(__linux__) && defined(SO_RXQ_OVFL)
-  int get_overflow = 1;
-  return 0 == setsockopt(fd, SOL_SOCKET, SO_RXQ_OVFL, &get_overflow,
-                         sizeof(get_overflow));
-#else
-  (void)fd;
-  return false;
-#endif
-}
-
-bool QuicUdpSocketApi::EnableReceiveSelfIpAddressForV4(QuicUdpSocketFd fd) {
-  int get_self_ip = 1;
-  return 0 == setsockopt(fd, IPPROTO_IP, IP_PKTINFO, &get_self_ip,
-                         sizeof(get_self_ip));
-}
-
-bool QuicUdpSocketApi::EnableReceiveSelfIpAddressForV6(QuicUdpSocketFd fd) {
-  int get_self_ip = 1;
-  return 0 == setsockopt(fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &get_self_ip,
-                         sizeof(get_self_ip));
-}
-
-bool QuicUdpSocketApi::EnableReceiveTimestamp(QuicUdpSocketFd fd) {
-#if defined(__linux__) && (!defined(__ANDROID_API__) || __ANDROID_API__ >= 21)
-  int timestamping = SOF_TIMESTAMPING_RX_SOFTWARE | SOF_TIMESTAMPING_SOFTWARE;
-  return 0 == setsockopt(fd, SOL_SOCKET, SO_TIMESTAMPING, &timestamping,
-                         sizeof(timestamping));
-#else
-  (void)fd;
-  return false;
-#endif
-}
-
-bool QuicUdpSocketApi::EnableReceiveTtlForV4(QuicUdpSocketFd fd) {
-#if defined(QUIC_UDP_SOCKET_SUPPORT_TTL)
-  int get_ttl = 1;
-  return 0 == setsockopt(fd, IPPROTO_IP, IP_RECVTTL, &get_ttl, sizeof(get_ttl));
-#else
-  (void)fd;
-  return false;
-#endif
-}
-
-bool QuicUdpSocketApi::EnableReceiveTtlForV6(QuicUdpSocketFd fd) {
-#if defined(QUIC_UDP_SOCKET_SUPPORT_TTL)
-  int get_ttl = 1;
-  return 0 == setsockopt(fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &get_ttl,
-                         sizeof(get_ttl));
-#else
-  (void)fd;
-  return false;
-#endif
-}
-
 bool QuicUdpSocketApi::WaitUntilReadable(QuicUdpSocketFd fd,
                                          QuicTime::Delta timeout) {
   fd_set read_fds;
diff --git a/quiche/quic/core/quic_udp_socket_win.inc b/quiche/quic/core/quic_udp_socket_win.inc
new file mode 100644
index 0000000..429b8c7
--- /dev/null
+++ b/quiche/quic/core/quic_udp_socket_win.inc
@@ -0,0 +1,281 @@
+// Copyright 2023 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// UDP socket implementation for Windows.  Feature overview:
+// * Supported: setting and getting self IP address.
+// * Unsupported but could work on a sufficiently new Windows version:
+//   - Timestamping
+//   - Setting and getting TTL.
+
+#include <mswsock.h>
+#include <winsock2.h>
+
+#include <cstddef>
+
+#include "quiche/quic/core/quic_utils.h"
+
+namespace quic {
+
+namespace {
+constexpr size_t kMinCmsgSpaceForRead =
+    CMSG_SPACE(sizeof(in_pktinfo))      // V4 Self IP
+    + CMSG_SPACE(sizeof(in6_pktinfo));  // V6 Self IP
+
+constexpr int kIpv6RecvPacketInfo = IPV6_PKTINFO;
+
+void SetV4SelfIpInControlMessage(const QuicIpAddress& self_address,
+                                 WSACMSGHDR* cmsg) {
+  QUICHE_DCHECK(self_address.IsIPv4());
+  in_pktinfo* pktinfo = reinterpret_cast<in_pktinfo*>(WSA_CMSG_DATA(cmsg));
+  memset(pktinfo, 0, sizeof(in_pktinfo));
+  pktinfo->ipi_addr = self_address.GetIPv4();
+}
+
+void SetV6SelfIpInControlMessage(const QuicIpAddress& self_address,
+                                 cmsghdr* cmsg) {
+  QUICHE_DCHECK(self_address.IsIPv6());
+  in6_pktinfo* pktinfo = reinterpret_cast<in6_pktinfo*>(WSA_CMSG_DATA(cmsg));
+  memset(pktinfo, 0, sizeof(in6_pktinfo));
+  pktinfo->ipi6_addr = self_address.GetIPv6();
+}
+
+bool NextCmsg(WSAMSG* hdr, char* control_buffer, size_t control_buffer_len,
+              int cmsg_level, int cmsg_type, size_t data_size,
+              WSACMSGHDR** cmsg /*in, out*/) {
+  // msg_controllen needs to be increased first, otherwise CMSG_NXTHDR will
+  // return nullptr.
+  hdr->Control.len += WSA_CMSG_SPACE(data_size);
+  if (hdr->Control.len > control_buffer_len) {
+    return false;
+  }
+
+  if ((*cmsg) == nullptr) {
+    QUICHE_DCHECK_EQ(nullptr, hdr->Control.buf);
+    memset(control_buffer, 0, control_buffer_len);
+    hdr->Control.buf = control_buffer;
+    (*cmsg) = WSA_CMSG_FIRSTHDR(hdr);
+  } else {
+    QUICHE_DCHECK_NE(nullptr, hdr->Control.buf);
+    (*cmsg) = WSA_CMSG_NXTHDR(hdr, (*cmsg));
+  }
+
+  if (nullptr == (*cmsg)) {
+    return false;
+  }
+
+  (*cmsg)->cmsg_len = WSA_CMSG_LEN(data_size);
+  (*cmsg)->cmsg_level = cmsg_level;
+  (*cmsg)->cmsg_type = cmsg_type;
+
+  return true;
+}
+}  // namespace
+
+bool QuicUdpSocketApi::SetupSocket(QuicUdpSocketFd fd, int address_family,
+                                   int receive_buffer_size,
+                                   int send_buffer_size, bool /*ipv6_only*/) {
+  // Receive buffer size.
+  if (absl::Status status =
+          socket_api::SetReceiveBufferSize(fd, receive_buffer_size);
+      !status.ok()) {
+    QUIC_LOG_FIRST_N(ERROR, 100)
+        << "Failed to set socket recv size: " << status;
+    return false;
+  }
+
+  // Send buffer size.
+  if (absl::Status status = socket_api::SetSendBufferSize(fd, send_buffer_size);
+      !status.ok()) {
+    QUIC_LOG_FIRST_N(ERROR, 100)
+        << "Failed to set socket send size: " << status;
+    return false;
+  }
+
+  if (address_family == AF_INET) {
+    if (!EnableReceiveSelfIpAddressForV4(fd)) {
+      QUIC_LOG_FIRST_N(ERROR, 100)
+          << "Failed to enable receiving of self v4 ip";
+      return false;
+    }
+  }
+
+  if (address_family == AF_INET6) {
+    if (!EnableReceiveSelfIpAddressForV6(fd)) {
+      QUIC_LOG_FIRST_N(ERROR, 100)
+          << "Failed to enable receiving of self v6 ip";
+      return false;
+    }
+  }
+
+  return true;
+}
+
+void QuicUdpSocketApi::ReadPacket(QuicUdpSocketFd fd,
+                                  BitMask64 packet_info_interested,
+                                  ReadPacketResult* result) {
+  result->ok = false;
+
+  // WSARecvMsg is an extension to Windows Socket API that requires us to fetch
+  // the function pointer via an ioctl.
+  DWORD recvmsg_fn_out_bytes;
+  LPFN_WSARECVMSG recvmsg_fn = nullptr;
+  GUID recvmsg_guid = WSAID_WSARECVMSG;
+  int ioctl_result =
+      WSAIoctl(fd, SIO_GET_EXTENSION_FUNCTION_POINTER, &recvmsg_guid,
+               sizeof(recvmsg_guid), &recvmsg_fn, sizeof(recvmsg_fn),
+               &recvmsg_fn_out_bytes, nullptr, nullptr);
+  if (ioctl_result != 0) {
+    QUICHE_LOG(ERROR) << "Failed to load WSARecvMsg() function, error code: "
+                      << WSAGetLastError();
+    return;
+  }
+
+  BufferSpan& packet_buffer = result->packet_buffer;
+  BufferSpan& control_buffer = result->control_buffer;
+  QuicUdpPacketInfo* packet_info = &result->packet_info;
+
+  QUICHE_DCHECK_GE(control_buffer.buffer_len, kMinCmsgSpaceForRead);
+
+  WSABUF iov;
+  iov.buf = packet_buffer.buffer;
+  iov.len = packet_buffer.buffer_len;
+  sockaddr_storage raw_peer_address;
+
+  if (control_buffer.buffer_len > 0) {
+    reinterpret_cast<WSACMSGHDR*>(control_buffer.buffer)->cmsg_len =
+        control_buffer.buffer_len;
+  }
+
+  WSAMSG hdr;
+  memset(&hdr, 0, sizeof(hdr));
+  hdr.name = reinterpret_cast<sockaddr*>(&raw_peer_address);
+  hdr.namelen = sizeof(raw_peer_address);
+  hdr.lpBuffers = &iov;
+  hdr.dwBufferCount = 1;
+  hdr.dwFlags = 0;
+  hdr.Control.buf = control_buffer.buffer;
+  hdr.Control.len = control_buffer.buffer_len;
+
+  DWORD bytes_read;
+  int recvmsg_result = recvmsg_fn(fd, &hdr, &bytes_read, nullptr, nullptr);
+  if (recvmsg_result != 0) {
+    const int error_num = WSAGetLastError();
+    if (error_num != WSAEWOULDBLOCK) {
+      QUIC_LOG_FIRST_N(ERROR, 100) << "Error reading packet: " << error_num;
+    }
+    return;
+  }
+
+  packet_buffer.buffer_len = bytes_read;
+  if (packet_info_interested.IsSet(QuicUdpPacketInfoBit::PEER_ADDRESS)) {
+    packet_info->SetPeerAddress(QuicSocketAddress(raw_peer_address));
+  }
+
+  if (hdr.Control.len > 0) {
+    for (WSACMSGHDR* cmsg = WSA_CMSG_FIRSTHDR(&hdr); cmsg != nullptr;
+         cmsg = WSA_CMSG_NXTHDR(&hdr, cmsg)) {
+      BitMask64 prior_bitmask = packet_info->bitmask();
+      PopulatePacketInfoFromControlMessageBase(cmsg, packet_info,
+                                               packet_info_interested);
+      if (packet_info->bitmask() == prior_bitmask) {
+        QUIC_DLOG(INFO) << "Ignored cmsg_level:" << cmsg->cmsg_level
+                        << ", cmsg_type:" << cmsg->cmsg_type;
+      }
+    }
+  }
+
+  result->ok = true;
+}
+
+size_t QuicUdpSocketApi::ReadMultiplePackets(QuicUdpSocketFd fd,
+                                             BitMask64 packet_info_interested,
+                                             ReadPacketResults* results) {
+  size_t num_packets = 0;
+  for (ReadPacketResult& result : *results) {
+    result.ok = false;
+  }
+  for (ReadPacketResult& result : *results) {
+    ReadPacket(fd, packet_info_interested, &result);
+    if (!result.ok && WSAGetLastError() == WSAEWOULDBLOCK) {
+      break;
+    }
+    ++num_packets;
+  }
+  return num_packets;
+}
+
+WriteResult QuicUdpSocketApi::WritePacket(
+    QuicUdpSocketFd fd, const char* packet_buffer, size_t packet_buffer_len,
+    const QuicUdpPacketInfo& packet_info) {
+  if (!packet_info.HasValue(QuicUdpPacketInfoBit::PEER_ADDRESS)) {
+    return WriteResult(WRITE_STATUS_ERROR, WSAEINVAL);
+  }
+
+  char control_buffer[512];
+  sockaddr_storage raw_peer_address =
+      packet_info.peer_address().generic_address();
+  WSABUF iov;
+  iov.buf = const_cast<char*>(packet_buffer);
+  iov.len = packet_buffer_len;
+
+  WSAMSG hdr;
+  memset(&hdr, 0, sizeof(hdr));
+  hdr.name = reinterpret_cast<sockaddr*>(&raw_peer_address);
+  hdr.namelen = packet_info.peer_address().host().IsIPv4()
+                    ? sizeof(sockaddr_in)
+                    : sizeof(sockaddr_in6);
+  hdr.lpBuffers = &iov;
+  hdr.dwBufferCount = 1;
+
+  WSACMSGHDR* cmsg = nullptr;
+
+  // Set self IP.
+  if (packet_info.HasValue(QuicUdpPacketInfoBit::V4_SELF_IP) &&
+      packet_info.self_v4_ip().IsInitialized()) {
+    if (!NextCmsg(&hdr, control_buffer, sizeof(control_buffer), IPPROTO_IP,
+                  IP_PKTINFO, sizeof(in_pktinfo), &cmsg)) {
+      QUIC_LOG_FIRST_N(ERROR, 100)
+          << "Not enough buffer to set self v4 ip address.";
+      return WriteResult(WRITE_STATUS_ERROR, EINVAL);
+    }
+    SetV4SelfIpInControlMessage(packet_info.self_v4_ip(), cmsg);
+  } else if (packet_info.HasValue(QuicUdpPacketInfoBit::V6_SELF_IP) &&
+             packet_info.self_v6_ip().IsInitialized()) {
+    if (!NextCmsg(&hdr, control_buffer, sizeof(control_buffer), IPPROTO_IPV6,
+                  IPV6_PKTINFO, sizeof(in6_pktinfo), &cmsg)) {
+      QUIC_LOG_FIRST_N(ERROR, 100)
+          << "Not enough buffer to set self v6 ip address.";
+      return WriteResult(WRITE_STATUS_ERROR, EINVAL);
+    }
+    SetV6SelfIpInControlMessage(packet_info.self_v6_ip(), cmsg);
+  }
+
+  DWORD bytes_sent;
+  int result =
+      WSASendMsg(fd, &hdr, /*dwFlags=*/0, &bytes_sent, nullptr, nullptr);
+  if (result == 0) {
+    return WriteResult(WRITE_STATUS_OK, bytes_sent);
+  }
+  int error = WSAGetLastError();
+  return WriteResult(
+      (error == WSAEWOULDBLOCK) ? WRITE_STATUS_BLOCKED : WRITE_STATUS_ERROR,
+      error);
+}
+
+bool QuicUdpSocketApi::WaitUntilReadable(QuicUdpSocketFd fd,
+                                         QuicTime::Delta timeout) {
+  WSAPOLLFD polled_fd;
+  polled_fd.fd = fd;
+  polled_fd.events = POLLIN;
+  polled_fd.revents = 0;
+
+  int result = ::WSAPoll(&polled_fd, 1, timeout.ToMilliseconds());
+  if (result == SOCKET_ERROR) {
+    QUICHE_LOG(ERROR) << "Error while calling WSAPoll(): " << WSAGetLastError();
+  }
+
+  return result > 0;
+}
+
+}  // namespace quic
diff --git a/quiche/quic/test_tools/quic_server_peer.cc b/quiche/quic/test_tools/quic_server_peer.cc
index 6f6c8f9..4ef81fb 100644
--- a/quiche/quic/test_tools/quic_server_peer.cc
+++ b/quiche/quic/test_tools/quic_server_peer.cc
@@ -14,8 +14,8 @@
 // static
 bool QuicServerPeer::SetSmallSocket(QuicServer* server) {
   int size = 1024 * 10;
-  return setsockopt(server->fd_, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size)) !=
-         -1;
+  return setsockopt(server->fd_, SOL_SOCKET, SO_RCVBUF,
+                    reinterpret_cast<char*>(&size), sizeof(size)) != -1;
 }
 
 // static
diff --git a/quiche/quic/test_tools/quic_test_client.cc b/quiche/quic/test_tools/quic_test_client.cc
index a617348..1f17227 100644
--- a/quiche/quic/test_tools/quic_test_client.cc
+++ b/quiche/quic/test_tools/quic_test_client.cc
@@ -365,7 +365,7 @@
   client_->SetUserAgentID(user_agent_id);
 }
 
-ssize_t QuicTestClient::SendRequest(const std::string& uri) {
+int64_t QuicTestClient::SendRequest(const std::string& uri) {
   spdy::Http2HeaderBlock headers;
   if (!PopulateHeaderBlockFromUrl(uri, &headers)) {
     return 0;
@@ -373,7 +373,7 @@
   return SendMessage(headers, "");
 }
 
-ssize_t QuicTestClient::SendRequestAndRstTogether(const std::string& uri) {
+int64_t QuicTestClient::SendRequestAndRstTogether(const std::string& uri) {
   spdy::Http2HeaderBlock headers;
   if (!PopulateHeaderBlockFromUrl(uri, &headers)) {
     return 0;
@@ -381,7 +381,7 @@
 
   QuicSpdyClientSession* session = client()->client_session();
   QuicConnection::ScopedPacketFlusher flusher(session->connection());
-  ssize_t ret = SendMessage(headers, "", /*fin=*/true, /*flush=*/false);
+  int64_t ret = SendMessage(headers, "", /*fin=*/true, /*flush=*/false);
 
   QuicStreamId stream_id = GetNthClientInitiatedBidirectionalStreamId(
       session->transport_version(), 0);
@@ -398,7 +398,7 @@
   }
 }
 
-ssize_t QuicTestClient::GetOrCreateStreamAndSendRequest(
+int64_t QuicTestClient::GetOrCreateStreamAndSendRequest(
     const spdy::Http2HeaderBlock* headers, absl::string_view body, bool fin,
     quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
         ack_listener) {
@@ -426,7 +426,7 @@
   }
   QuicSpdyStreamPeer::set_ack_listener(stream, ack_listener);
 
-  ssize_t ret = 0;
+  int64_t ret = 0;
   if (headers != nullptr) {
     spdy::Http2HeaderBlock spdy_headers(headers->Clone());
     if (spdy_headers[":authority"].as_string().empty()) {
@@ -441,23 +441,23 @@
   return ret;
 }
 
-ssize_t QuicTestClient::SendMessage(const spdy::Http2HeaderBlock& headers,
+int64_t QuicTestClient::SendMessage(const spdy::Http2HeaderBlock& headers,
                                     absl::string_view body) {
   return SendMessage(headers, body, /*fin=*/true);
 }
 
-ssize_t QuicTestClient::SendMessage(const spdy::Http2HeaderBlock& headers,
+int64_t QuicTestClient::SendMessage(const spdy::Http2HeaderBlock& headers,
                                     absl::string_view body, bool fin) {
   return SendMessage(headers, body, fin, /*flush=*/true);
 }
 
-ssize_t QuicTestClient::SendMessage(const spdy::Http2HeaderBlock& headers,
+int64_t QuicTestClient::SendMessage(const spdy::Http2HeaderBlock& headers,
                                     absl::string_view body, bool fin,
                                     bool flush) {
   // Always force creation of a stream for SendMessage.
   latest_created_stream_ = nullptr;
 
-  ssize_t ret = GetOrCreateStreamAndSendRequest(&headers, body, fin, nullptr);
+  int64_t ret = GetOrCreateStreamAndSendRequest(&headers, body, fin, nullptr);
 
   if (flush) {
     WaitForWriteToFlush();
@@ -465,11 +465,11 @@
   return ret;
 }
 
-ssize_t QuicTestClient::SendData(const std::string& data, bool last_data) {
+int64_t QuicTestClient::SendData(const std::string& data, bool last_data) {
   return SendData(data, last_data, nullptr);
 }
 
-ssize_t QuicTestClient::SendData(
+int64_t QuicTestClient::SendData(
     const std::string& data, bool last_data,
     quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
         ack_listener) {
@@ -645,7 +645,7 @@
   return true;
 }
 
-ssize_t QuicTestClient::Send(absl::string_view data) {
+int64_t QuicTestClient::Send(absl::string_view data) {
   return SendData(std::string(data), false);
 }
 
diff --git a/quiche/quic/test_tools/quic_test_client.h b/quiche/quic/test_tools/quic_test_client.h
index 9abab23..9f2a869 100644
--- a/quiche/quic/test_tools/quic_test_client.h
+++ b/quiche/quic/test_tools/quic_test_client.h
@@ -115,18 +115,18 @@
   void SetUserAgentID(const std::string& user_agent_id);
 
   // Wraps data in a quic packet and sends it.
-  ssize_t SendData(const std::string& data, bool last_data);
+  int64_t SendData(const std::string& data, bool last_data);
   // As above, but |delegate| will be notified when |data| is ACKed.
-  ssize_t SendData(
+  int64_t SendData(
       const std::string& data, bool last_data,
       quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
           ack_listener);
 
   // Clears any outstanding state and sends a simple GET of 'uri' to the
   // server.  Returns 0 if the request failed and no bytes were written.
-  ssize_t SendRequest(const std::string& uri);
+  int64_t SendRequest(const std::string& uri);
   // Send a request R and a RST_FRAME which resets R, in the same packet.
-  ssize_t SendRequestAndRstTogether(const std::string& uri);
+  int64_t SendRequestAndRstTogether(const std::string& uri);
   // Sends requests for all the urls and waits for the responses.  To process
   // the individual responses as they are returned, the caller should use the
   // set the response_listener on the client().
@@ -134,18 +134,18 @@
       const std::vector<std::string>& url_list);
   // Sends a request containing |headers| and |body| and returns the number of
   // bytes sent (the size of the serialized request headers and body).
-  ssize_t SendMessage(const spdy::Http2HeaderBlock& headers,
+  int64_t SendMessage(const spdy::Http2HeaderBlock& headers,
                       absl::string_view body);
   // Sends a request containing |headers| and |body| with the fin bit set to
   // |fin| and returns the number of bytes sent (the size of the serialized
   // request headers and body).
-  ssize_t SendMessage(const spdy::Http2HeaderBlock& headers,
+  int64_t SendMessage(const spdy::Http2HeaderBlock& headers,
                       absl::string_view body, bool fin);
   // Sends a request containing |headers| and |body| with the fin bit set to
   // |fin| and returns the number of bytes sent (the size of the serialized
   // request headers and body). If |flush| is true, will wait for the message to
   // be flushed before returning.
-  ssize_t SendMessage(const spdy::Http2HeaderBlock& headers,
+  int64_t SendMessage(const spdy::Http2HeaderBlock& headers,
                       absl::string_view body, bool fin, bool flush);
   // Sends a request containing |headers| and |body|, waits for the response,
   // and returns the response body.
@@ -161,7 +161,7 @@
   QuicSocketAddress local_address() const;
   void ClearPerRequestState();
   bool WaitUntil(int timeout_ms, std::function<bool()> trigger);
-  ssize_t Send(absl::string_view data);
+  int64_t Send(absl::string_view data);
   bool connected() const;
   bool buffer_body() const;
   void set_buffer_body(bool buffer_body);
@@ -259,7 +259,7 @@
   // Calls GetOrCreateStream(), sends the request on the stream, and
   // stores the request in case it needs to be resent.  If |headers| is
   // null, only the body will be sent on the stream.
-  ssize_t GetOrCreateStreamAndSendRequest(
+  int64_t GetOrCreateStreamAndSendRequest(
       const spdy::Http2HeaderBlock* headers, absl::string_view body, bool fin,
       quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>
           ack_listener);
diff --git a/quiche/quic/tools/quic_client_default_network_helper.cc b/quiche/quic/tools/quic_client_default_network_helper.cc
index ab9e1b1..424b8b9 100644
--- a/quiche/quic/tools/quic_client_default_network_helper.cc
+++ b/quiche/quic/tools/quic_client_default_network_helper.cc
@@ -22,7 +22,7 @@
 // listener whenever the socket gets blocked.
 class LevelTriggeredPacketWriter : public QuicDefaultPacketWriter {
  public:
-  explicit LevelTriggeredPacketWriter(int fd, QuicEventLoop* event_loop)
+  explicit LevelTriggeredPacketWriter(SocketFd fd, QuicEventLoop* event_loop)
       : QuicDefaultPacketWriter(fd), event_loop_(event_loop) {
     QUICHE_DCHECK(!event_loop->SupportsEdgeTriggered());
   }
@@ -68,11 +68,11 @@
 bool QuicClientDefaultNetworkHelper::CreateUDPSocketAndBind(
     QuicSocketAddress server_address, QuicIpAddress bind_to_address,
     int bind_to_port) {
-  int fd = CreateUDPSocket(server_address, &overflow_supported_);
-  if (fd < 0) {
+  SocketFd fd = CreateUDPSocket(server_address, &overflow_supported_);
+  if (fd == kInvalidSocketFd) {
     return false;
   }
-  auto closer = absl::MakeCleanup([fd] { close(fd); });
+  auto closer = absl::MakeCleanup([fd] { (void)socket_api::Close(fd); });
 
   QuicSocketAddress client_address;
   if (bind_to_address.IsInitialized()) {
@@ -124,7 +124,7 @@
   return false;
 }
 
-void QuicClientDefaultNetworkHelper::CleanUpUDPSocket(int fd) {
+void QuicClientDefaultNetworkHelper::CleanUpUDPSocket(SocketFd fd) {
   CleanUpUDPSocketImpl(fd);
   fd_address_map_.erase(fd);
 }
@@ -136,12 +136,12 @@
   fd_address_map_.clear();
 }
 
-void QuicClientDefaultNetworkHelper::CleanUpUDPSocketImpl(int fd) {
-  if (fd > -1) {
+void QuicClientDefaultNetworkHelper::CleanUpUDPSocketImpl(SocketFd fd) {
+  if (fd != kInvalidSocketFd) {
     bool success = event_loop_->UnregisterSocket(fd);
     QUICHE_DCHECK(success || fds_unregistered_externally_);
-    int rc = close(fd);
-    QUICHE_DCHECK_EQ(0, rc);
+    absl::Status rc = socket_api::Close(fd);
+    QUICHE_DCHECK(rc.ok()) << rc;
   }
 }
 
@@ -207,7 +207,7 @@
   return fd_address_map_.back().second;
 }
 
-int QuicClientDefaultNetworkHelper::GetLatestFD() const {
+SocketFd QuicClientDefaultNetworkHelper::GetLatestFD() const {
   if (fd_address_map_.empty()) {
     return -1;
   }
@@ -221,13 +221,13 @@
   client_->session()->ProcessUdpPacket(self_address, peer_address, packet);
 }
 
-int QuicClientDefaultNetworkHelper::CreateUDPSocket(
+SocketFd QuicClientDefaultNetworkHelper::CreateUDPSocket(
     QuicSocketAddress server_address, bool* overflow_supported) {
   QuicUdpSocketApi api;
-  int fd = api.Create(server_address.host().AddressFamilyToInt(),
-                      /*receive_buffer_size =*/kDefaultSocketReceiveBuffer,
-                      /*send_buffer_size =*/kDefaultSocketReceiveBuffer);
-  if (fd < 0) {
+  SocketFd fd = api.Create(server_address.host().AddressFamilyToInt(),
+                           /*receive_buffer_size =*/kDefaultSocketReceiveBuffer,
+                           /*send_buffer_size =*/kDefaultSocketReceiveBuffer);
+  if (fd == kInvalidSocketFd) {
     return fd;
   }
 
@@ -242,7 +242,7 @@
   return fd;
 }
 
-bool QuicClientDefaultNetworkHelper::BindInterfaceNameIfNeeded(int fd) {
+bool QuicClientDefaultNetworkHelper::BindInterfaceNameIfNeeded(SocketFd fd) {
   QuicUdpSocketApi api;
   std::string interface_name = client_->interface_name();
   if (!interface_name.empty()) {
diff --git a/quiche/quic/tools/quic_client_default_network_helper.h b/quiche/quic/tools/quic_client_default_network_helper.h
index 07b0753..f62bd80 100644
--- a/quiche/quic/tools/quic_client_default_network_helper.h
+++ b/quiche/quic/tools/quic_client_default_network_helper.h
@@ -58,20 +58,19 @@
 
   // Accessors provided for convenience, not part of any interface.
   QuicEventLoop* event_loop() { return event_loop_; }
-  const quiche::QuicheLinkedHashMap<int, QuicSocketAddress>& fd_address_map()
-      const {
+  const quiche::QuicheLinkedHashMap<SocketFd, QuicSocketAddress>&
+  fd_address_map() const {
     return fd_address_map_;
   }
 
   // If the client has at least one UDP socket, return the latest created one.
   // Otherwise, return -1.
-  int GetLatestFD() const;
+  SocketFd GetLatestFD() const;
 
-  // Create socket for connection to |server_address| with default socket
-  // options.
-  // Return fd index.
-  virtual int CreateUDPSocket(QuicSocketAddress server_address,
-                              bool* overflow_supported);
+  // Create a socket for connection to |server_address| with default socket
+  // options. Returns the FD of the resulting socket.
+  virtual SocketFd CreateUDPSocket(QuicSocketAddress server_address,
+                                   bool* overflow_supported);
 
   QuicClientBase* client() { return client_; }
 
@@ -80,7 +79,7 @@
   }
   // If |fd| is an open UDP socket, unregister and close it. Otherwise, do
   // nothing.
-  void CleanUpUDPSocket(int fd);
+  void CleanUpUDPSocket(SocketFd fd);
 
   // Used for testing.
   void SetClientPort(int port);
@@ -94,10 +93,10 @@
   }
 
   // Bind a socket to a specific network interface.
-  bool BindInterfaceNameIfNeeded(int fd);
+  bool BindInterfaceNameIfNeeded(SocketFd fd);
 
   // Actually clean up |fd|.
-  virtual void CleanUpUDPSocketImpl(int fd);
+  virtual void CleanUpUDPSocketImpl(SocketFd fd);
 
  private:
   // Listens for events on the client socket.
@@ -105,7 +104,7 @@
 
   // Map mapping created UDP sockets to their addresses. By using linked hash
   // map, the order of socket creation can be recorded.
-  quiche::QuicheLinkedHashMap<int, QuicSocketAddress> fd_address_map_;
+  quiche::QuicheLinkedHashMap<SocketFd, QuicSocketAddress> fd_address_map_;
 
   // If overflow_supported_ is true, this will be the number of packets dropped
   // during the lifetime of the server.
diff --git a/quiche/quic/tools/quic_server.cc b/quiche/quic/tools/quic_server.cc
index 738d8c9..63e9aca 100644
--- a/quiche/quic/tools/quic_server.cc
+++ b/quiche/quic/tools/quic_server.cc
@@ -97,8 +97,8 @@
 }
 
 QuicServer::~QuicServer() {
-  close(fd_);
-  fd_ = -1;
+  (void)socket_api::Close(fd_);
+  fd_ = kInvalidSocketFd;
 
   // Should be fine without because nothing should send requests to the backend
   // after `this` is destroyed, but for extra pointer safety, clear the socket