diff --git a/rtc_base/BUILD.gn b/rtc_base/BUILD.gn
index ec59c43..5165a3e 100644
--- a/rtc_base/BUILD.gn
+++ b/rtc_base/BUILD.gn
@@ -1065,12 +1065,6 @@
 
     if (is_win) {
       sources += [ "win32_socket_init.h" ]
-      if (current_os != "winuwp") {
-        sources += [
-          "win32_socket_server.cc",
-          "win32_socket_server.h",
-        ]
-      }
     }
   }  # !build_with_chromium
 
@@ -1328,9 +1322,6 @@
         "//testing/gtest",
       ]
       absl_deps = [ "//third_party/abseil-cpp/absl/memory" ]
-      if (is_win) {
-        sources += [ "win32_socket_server_unittest.cc" ]
-      }
     }
 
     rtc_library("rtc_base_approved_unittests") {
diff --git a/rtc_base/win32_socket_server.cc b/rtc_base/win32_socket_server.cc
deleted file mode 100644
index 3f3a826..0000000
--- a/rtc_base/win32_socket_server.cc
+++ /dev/null
@@ -1,813 +0,0 @@
-/*
- *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#include "rtc_base/win32_socket_server.h"
-
-#include <ws2tcpip.h>  // NOLINT
-
-#include <algorithm>
-
-#include "rtc_base/byte_order.h"
-#include "rtc_base/checks.h"
-#include "rtc_base/logging.h"
-#include "rtc_base/time_utils.h"  // For Time, TimeSince
-#include "rtc_base/win32_window.h"
-
-namespace rtc {
-
-///////////////////////////////////////////////////////////////////////////////
-// Win32Socket
-///////////////////////////////////////////////////////////////////////////////
-
-// TODO: Enable for production builds also? Use FormatMessage?
-#if !defined(NDEBUG)
-LPCSTR WSAErrorToString(int error, LPCSTR* description_result) {
-  LPCSTR string = "Unspecified";
-  LPCSTR description = "Unspecified description";
-  switch (error) {
-    case ERROR_SUCCESS:
-      string = "SUCCESS";
-      description = "Operation succeeded";
-      break;
-    case WSAEWOULDBLOCK:
-      string = "WSAEWOULDBLOCK";
-      description = "Using a non-blocking socket, will notify later";
-      break;
-    case WSAEACCES:
-      string = "WSAEACCES";
-      description = "Access denied, or sharing violation";
-      break;
-    case WSAEADDRNOTAVAIL:
-      string = "WSAEADDRNOTAVAIL";
-      description = "Address is not valid in this context";
-      break;
-    case WSAENETDOWN:
-      string = "WSAENETDOWN";
-      description = "Network is down";
-      break;
-    case WSAENETUNREACH:
-      string = "WSAENETUNREACH";
-      description = "Network is up, but unreachable";
-      break;
-    case WSAENETRESET:
-      string = "WSANETRESET";
-      description = "Connection has been reset due to keep-alive activity";
-      break;
-    case WSAECONNABORTED:
-      string = "WSAECONNABORTED";
-      description = "Aborted by host";
-      break;
-    case WSAECONNRESET:
-      string = "WSAECONNRESET";
-      description = "Connection reset by host";
-      break;
-    case WSAETIMEDOUT:
-      string = "WSAETIMEDOUT";
-      description = "Timed out, host failed to respond";
-      break;
-    case WSAECONNREFUSED:
-      string = "WSAECONNREFUSED";
-      description = "Host actively refused connection";
-      break;
-    case WSAEHOSTDOWN:
-      string = "WSAEHOSTDOWN";
-      description = "Host is down";
-      break;
-    case WSAEHOSTUNREACH:
-      string = "WSAEHOSTUNREACH";
-      description = "Host is unreachable";
-      break;
-    case WSAHOST_NOT_FOUND:
-      string = "WSAHOST_NOT_FOUND";
-      description = "No such host is known";
-      break;
-  }
-  if (description_result) {
-    *description_result = description;
-  }
-  return string;
-}
-
-void ReportWSAError(LPCSTR context, int error, const SocketAddress& address) {
-  LPCSTR description_string;
-  LPCSTR error_string = WSAErrorToString(error, &description_string);
-  RTC_LOG(LS_INFO) << context << " = " << error << " (" << error_string << ":"
-                   << description_string << ") [" << address.ToString() << "]";
-}
-#else
-void ReportWSAError(LPCSTR context, int error, const SocketAddress& address) {}
-#endif
-
-/////////////////////////////////////////////////////////////////////////////
-// Win32Socket::EventSink
-/////////////////////////////////////////////////////////////////////////////
-
-#define WM_SOCKETNOTIFY (WM_USER + 50)
-#define WM_DNSNOTIFY (WM_USER + 51)
-
-struct Win32Socket::DnsLookup {
-  HANDLE handle;
-  uint16_t port;
-  char buffer[MAXGETHOSTSTRUCT];
-};
-
-class Win32Socket::EventSink : public Win32Window {
- public:
-  explicit EventSink(Win32Socket* parent) : parent_(parent) {}
-
-  void Dispose();
-
-  bool OnMessage(UINT uMsg,
-                 WPARAM wParam,
-                 LPARAM lParam,
-                 LRESULT& result) override;
-  void OnNcDestroy() override;
-
- private:
-  bool OnSocketNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT& result);
-  bool OnDnsNotify(WPARAM wParam, LPARAM lParam, LRESULT& result);
-
-  Win32Socket* parent_;
-};
-
-void Win32Socket::EventSink::Dispose() {
-  parent_ = nullptr;
-  if (::IsWindow(handle())) {
-    ::DestroyWindow(handle());
-  } else {
-    delete this;
-  }
-}
-
-bool Win32Socket::EventSink::OnMessage(UINT uMsg,
-                                       WPARAM wParam,
-                                       LPARAM lParam,
-                                       LRESULT& result) {
-  switch (uMsg) {
-    case WM_SOCKETNOTIFY:
-    case WM_TIMER:
-      return OnSocketNotify(uMsg, wParam, lParam, result);
-    case WM_DNSNOTIFY:
-      return OnDnsNotify(wParam, lParam, result);
-  }
-  return false;
-}
-
-bool Win32Socket::EventSink::OnSocketNotify(UINT uMsg,
-                                            WPARAM wParam,
-                                            LPARAM lParam,
-                                            LRESULT& result) {
-  result = 0;
-
-  int wsa_event = WSAGETSELECTEVENT(lParam);
-  int wsa_error = WSAGETSELECTERROR(lParam);
-
-  // Treat connect timeouts as close notifications
-  if (uMsg == WM_TIMER) {
-    wsa_event = FD_CLOSE;
-    wsa_error = WSAETIMEDOUT;
-  }
-
-  if (parent_)
-    parent_->OnSocketNotify(static_cast<SOCKET>(wParam), wsa_event, wsa_error);
-  return true;
-}
-
-bool Win32Socket::EventSink::OnDnsNotify(WPARAM wParam,
-                                         LPARAM lParam,
-                                         LRESULT& result) {
-  result = 0;
-
-  int error = WSAGETASYNCERROR(lParam);
-  if (parent_)
-    parent_->OnDnsNotify(reinterpret_cast<HANDLE>(wParam), error);
-  return true;
-}
-
-void Win32Socket::EventSink::OnNcDestroy() {
-  if (parent_) {
-    RTC_LOG(LS_ERROR) << "EventSink hwnd is being destroyed, but the event sink"
-                         " hasn't yet been disposed.";
-  } else {
-    delete this;
-  }
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Win32Socket
-/////////////////////////////////////////////////////////////////////////////
-
-Win32Socket::Win32Socket()
-    : socket_(INVALID_SOCKET),
-      error_(0),
-      state_(CS_CLOSED),
-      connect_time_(0),
-      closing_(false),
-      close_error_(0),
-      sink_(nullptr),
-      dns_(nullptr) {}
-
-Win32Socket::~Win32Socket() {
-  Close();
-}
-
-bool Win32Socket::CreateT(int family, int type) {
-  Close();
-  int proto = (SOCK_DGRAM == type) ? IPPROTO_UDP : IPPROTO_TCP;
-  socket_ = ::WSASocket(family, type, proto, nullptr, 0, 0);
-  if (socket_ == INVALID_SOCKET) {
-    UpdateLastError();
-    return false;
-  }
-  if ((SOCK_DGRAM == type) && !SetAsync(FD_READ | FD_WRITE)) {
-    return false;
-  }
-  return true;
-}
-
-int Win32Socket::Attach(SOCKET s) {
-  RTC_DCHECK(socket_ == INVALID_SOCKET);
-  if (socket_ != INVALID_SOCKET)
-    return SOCKET_ERROR;
-
-  RTC_DCHECK(s != INVALID_SOCKET);
-  if (s == INVALID_SOCKET)
-    return SOCKET_ERROR;
-
-  socket_ = s;
-  state_ = CS_CONNECTED;
-
-  if (!SetAsync(FD_READ | FD_WRITE | FD_CLOSE))
-    return SOCKET_ERROR;
-
-  return 0;
-}
-
-void Win32Socket::SetTimeout(int ms) {
-  if (sink_)
-    ::SetTimer(sink_->handle(), 1, ms, 0);
-}
-
-SocketAddress Win32Socket::GetLocalAddress() const {
-  sockaddr_storage addr = {0};
-  socklen_t addrlen = sizeof(addr);
-  int result =
-      ::getsockname(socket_, reinterpret_cast<sockaddr*>(&addr), &addrlen);
-  SocketAddress address;
-  if (result >= 0) {
-    SocketAddressFromSockAddrStorage(addr, &address);
-  } else {
-    RTC_LOG(LS_WARNING) << "GetLocalAddress: unable to get local addr, socket="
-                        << socket_;
-  }
-  return address;
-}
-
-SocketAddress Win32Socket::GetRemoteAddress() const {
-  sockaddr_storage addr = {0};
-  socklen_t addrlen = sizeof(addr);
-  int result =
-      ::getpeername(socket_, reinterpret_cast<sockaddr*>(&addr), &addrlen);
-  SocketAddress address;
-  if (result >= 0) {
-    SocketAddressFromSockAddrStorage(addr, &address);
-  } else {
-    RTC_LOG(LS_WARNING)
-        << "GetRemoteAddress: unable to get remote addr, socket=" << socket_;
-  }
-  return address;
-}
-
-int Win32Socket::Bind(const SocketAddress& addr) {
-  RTC_DCHECK(socket_ != INVALID_SOCKET);
-  if (socket_ == INVALID_SOCKET)
-    return SOCKET_ERROR;
-
-  sockaddr_storage saddr;
-  size_t len = addr.ToSockAddrStorage(&saddr);
-  int err = ::bind(socket_, reinterpret_cast<sockaddr*>(&saddr),
-                   static_cast<int>(len));
-  UpdateLastError();
-  return err;
-}
-
-int Win32Socket::Connect(const SocketAddress& addr) {
-  if (state_ != CS_CLOSED) {
-    SetError(EALREADY);
-    return SOCKET_ERROR;
-  }
-
-  if (!addr.IsUnresolvedIP()) {
-    return DoConnect(addr);
-  }
-
-  RTC_LOG_F(LS_INFO) << "async dns lookup (" << addr.hostname() << ")";
-  DnsLookup* dns = new DnsLookup;
-  if (!sink_) {
-    // Explicitly create the sink ourselves here; we can't rely on SetAsync
-    // because we don't have a socket_ yet.
-    CreateSink();
-  }
-  // TODO: Replace with IPv6 compatible lookup.
-  dns->handle = WSAAsyncGetHostByName(sink_->handle(), WM_DNSNOTIFY,
-                                      addr.hostname().c_str(), dns->buffer,
-                                      sizeof(dns->buffer));
-
-  if (!dns->handle) {
-    RTC_LOG_F(LS_ERROR) << "WSAAsyncGetHostByName error: " << WSAGetLastError();
-    delete dns;
-    UpdateLastError();
-    Close();
-    return SOCKET_ERROR;
-  }
-
-  dns->port = addr.port();
-  dns_ = dns;
-  state_ = CS_CONNECTING;
-  return 0;
-}
-
-int Win32Socket::DoConnect(const SocketAddress& addr) {
-  if ((socket_ == INVALID_SOCKET) && !CreateT(addr.family(), SOCK_STREAM)) {
-    return SOCKET_ERROR;
-  }
-  if (!SetAsync(FD_READ | FD_WRITE | FD_CONNECT | FD_CLOSE)) {
-    return SOCKET_ERROR;
-  }
-
-  sockaddr_storage saddr = {0};
-  size_t len = addr.ToSockAddrStorage(&saddr);
-  connect_time_ = Time();
-  int result = connect(socket_, reinterpret_cast<SOCKADDR*>(&saddr),
-                       static_cast<int>(len));
-  if (result != SOCKET_ERROR) {
-    state_ = CS_CONNECTED;
-  } else {
-    int code = WSAGetLastError();
-    if (code == WSAEWOULDBLOCK) {
-      state_ = CS_CONNECTING;
-    } else {
-      ReportWSAError("WSAAsync:connect", code, addr);
-      error_ = code;
-      Close();
-      return SOCKET_ERROR;
-    }
-  }
-  addr_ = addr;
-
-  return 0;
-}
-
-int Win32Socket::GetError() const {
-  return error_;
-}
-
-void Win32Socket::SetError(int error) {
-  error_ = error;
-}
-
-Socket::ConnState Win32Socket::GetState() const {
-  return state_;
-}
-
-int Win32Socket::GetOption(Option opt, int* value) {
-  int slevel;
-  int sopt;
-  if (TranslateOption(opt, &slevel, &sopt) == -1)
-    return -1;
-
-  char* p = reinterpret_cast<char*>(value);
-  int optlen = sizeof(value);
-  return ::getsockopt(socket_, slevel, sopt, p, &optlen);
-}
-
-int Win32Socket::SetOption(Option opt, int value) {
-  int slevel;
-  int sopt;
-  if (TranslateOption(opt, &slevel, &sopt) == -1)
-    return -1;
-
-  const char* p = reinterpret_cast<const char*>(&value);
-  return ::setsockopt(socket_, slevel, sopt, p, sizeof(value));
-}
-
-int Win32Socket::Send(const void* buffer, size_t length) {
-  int sent = ::send(socket_, reinterpret_cast<const char*>(buffer),
-                    static_cast<int>(length), 0);
-  UpdateLastError();
-  return sent;
-}
-
-int Win32Socket::SendTo(const void* buffer,
-                        size_t length,
-                        const SocketAddress& addr) {
-  sockaddr_storage saddr;
-  size_t addr_len = addr.ToSockAddrStorage(&saddr);
-  int sent = ::sendto(
-      socket_, reinterpret_cast<const char*>(buffer), static_cast<int>(length),
-      0, reinterpret_cast<sockaddr*>(&saddr), static_cast<int>(addr_len));
-  UpdateLastError();
-  return sent;
-}
-
-int Win32Socket::Recv(void* buffer, size_t length, int64_t* timestamp) {
-  if (timestamp) {
-    *timestamp = -1;
-  }
-  int received =
-      ::recv(socket_, static_cast<char*>(buffer), static_cast<int>(length), 0);
-  UpdateLastError();
-  if (closing_ && received <= static_cast<int>(length))
-    PostClosed();
-  return received;
-}
-
-int Win32Socket::RecvFrom(void* buffer,
-                          size_t length,
-                          SocketAddress* out_addr,
-                          int64_t* timestamp) {
-  if (timestamp) {
-    *timestamp = -1;
-  }
-  sockaddr_storage saddr;
-  socklen_t addr_len = sizeof(saddr);
-  int received =
-      ::recvfrom(socket_, static_cast<char*>(buffer), static_cast<int>(length),
-                 0, reinterpret_cast<sockaddr*>(&saddr), &addr_len);
-  UpdateLastError();
-  if (received != SOCKET_ERROR)
-    SocketAddressFromSockAddrStorage(saddr, out_addr);
-  if (closing_ && received <= static_cast<int>(length))
-    PostClosed();
-  return received;
-}
-
-int Win32Socket::Listen(int backlog) {
-  int err = ::listen(socket_, backlog);
-  if (!SetAsync(FD_ACCEPT))
-    return SOCKET_ERROR;
-
-  UpdateLastError();
-  if (err == 0)
-    state_ = CS_CONNECTING;
-  return err;
-}
-
-Win32Socket* Win32Socket::Accept(SocketAddress* out_addr) {
-  sockaddr_storage saddr;
-  socklen_t addr_len = sizeof(saddr);
-  SOCKET s = ::accept(socket_, reinterpret_cast<sockaddr*>(&saddr), &addr_len);
-  UpdateLastError();
-  if (s == INVALID_SOCKET)
-    return nullptr;
-  if (out_addr)
-    SocketAddressFromSockAddrStorage(saddr, out_addr);
-  Win32Socket* socket = new Win32Socket;
-  if (0 == socket->Attach(s))
-    return socket;
-  delete socket;
-  return nullptr;
-}
-
-int Win32Socket::Close() {
-  int err = 0;
-  if (socket_ != INVALID_SOCKET) {
-    err = ::closesocket(socket_);
-    socket_ = INVALID_SOCKET;
-    closing_ = false;
-    close_error_ = 0;
-    UpdateLastError();
-  }
-  if (dns_) {
-    WSACancelAsyncRequest(dns_->handle);
-    delete dns_;
-    dns_ = nullptr;
-  }
-  if (sink_) {
-    sink_->Dispose();
-    sink_ = nullptr;
-  }
-  addr_.Clear();
-  state_ = CS_CLOSED;
-  return err;
-}
-
-void Win32Socket::CreateSink() {
-  RTC_DCHECK(nullptr == sink_);
-
-  // Create window
-  sink_ = new EventSink(this);
-  sink_->Create(nullptr, L"EventSink", 0, 0, 0, 0, 10, 10);
-}
-
-bool Win32Socket::SetAsync(int events) {
-  if (nullptr == sink_) {
-    CreateSink();
-    RTC_DCHECK(nullptr != sink_);
-  }
-
-  // start the async select
-  if (WSAAsyncSelect(socket_, sink_->handle(), WM_SOCKETNOTIFY, events) ==
-      SOCKET_ERROR) {
-    UpdateLastError();
-    Close();
-    return false;
-  }
-
-  return true;
-}
-
-bool Win32Socket::HandleClosed(int close_error) {
-  // WM_CLOSE will be received before all data has been read, so we need to
-  // hold on to it until the read buffer has been drained.
-  char ch;
-  closing_ = true;
-  close_error_ = close_error;
-  return (::recv(socket_, &ch, 1, MSG_PEEK) <= 0);
-}
-
-void Win32Socket::PostClosed() {
-  // If we see that the buffer is indeed drained, then send the close.
-  closing_ = false;
-  ::PostMessage(sink_->handle(), WM_SOCKETNOTIFY, socket_,
-                WSAMAKESELECTREPLY(FD_CLOSE, close_error_));
-}
-
-void Win32Socket::UpdateLastError() {
-  error_ = WSAGetLastError();
-}
-
-int Win32Socket::TranslateOption(Option opt, int* slevel, int* sopt) {
-  switch (opt) {
-    case OPT_DONTFRAGMENT:
-      *slevel = IPPROTO_IP;
-      *sopt = IP_DONTFRAGMENT;
-      break;
-    case OPT_RCVBUF:
-      *slevel = SOL_SOCKET;
-      *sopt = SO_RCVBUF;
-      break;
-    case OPT_SNDBUF:
-      *slevel = SOL_SOCKET;
-      *sopt = SO_SNDBUF;
-      break;
-    case OPT_NODELAY:
-      *slevel = IPPROTO_TCP;
-      *sopt = TCP_NODELAY;
-      break;
-    case OPT_DSCP:
-      RTC_LOG(LS_WARNING) << "Socket::OPT_DSCP not supported.";
-      return -1;
-    default:
-      RTC_DCHECK_NOTREACHED();
-      return -1;
-  }
-  return 0;
-}
-
-void Win32Socket::OnSocketNotify(SOCKET socket, int event, int error) {
-  // Ignore events if we're already closed.
-  if (socket != socket_)
-    return;
-
-  error_ = error;
-  switch (event) {
-    case FD_CONNECT:
-      if (error != ERROR_SUCCESS) {
-        ReportWSAError("WSAAsync:connect notify", error, addr_);
-#if !defined(NDEBUG)
-        int64_t duration = TimeSince(connect_time_);
-        RTC_LOG(LS_INFO) << "WSAAsync:connect error (" << duration
-                         << " ms), faking close";
-#endif
-        state_ = CS_CLOSED;
-        // If you get an error connecting, close doesn't really do anything
-        // and it certainly doesn't send back any close notification, but
-        // we really only maintain a few states, so it is easiest to get
-        // back into a known state by pretending that a close happened, even
-        // though the connect event never did occur.
-        SignalCloseEvent(this, error);
-      } else {
-#if !defined(NDEBUG)
-        int64_t duration = TimeSince(connect_time_);
-        RTC_LOG(LS_INFO) << "WSAAsync:connect (" << duration << " ms)";
-#endif
-        state_ = CS_CONNECTED;
-        SignalConnectEvent(this);
-      }
-      break;
-
-    case FD_ACCEPT:
-    case FD_READ:
-      if (error != ERROR_SUCCESS) {
-        ReportWSAError("WSAAsync:read notify", error, addr_);
-      } else {
-        SignalReadEvent(this);
-      }
-      break;
-
-    case FD_WRITE:
-      if (error != ERROR_SUCCESS) {
-        ReportWSAError("WSAAsync:write notify", error, addr_);
-      } else {
-        SignalWriteEvent(this);
-      }
-      break;
-
-    case FD_CLOSE:
-      if (HandleClosed(error)) {
-        ReportWSAError("WSAAsync:close notify", error, addr_);
-        state_ = CS_CLOSED;
-        SignalCloseEvent(this, error);
-      }
-      break;
-  }
-}
-
-void Win32Socket::OnDnsNotify(HANDLE task, int error) {
-  if (!dns_ || dns_->handle != task)
-    return;
-
-  uint32_t ip = 0;
-  if (error == 0) {
-    hostent* pHost = reinterpret_cast<hostent*>(dns_->buffer);
-    uint32_t net_ip = *reinterpret_cast<uint32_t*>(pHost->h_addr_list[0]);
-    ip = NetworkToHost32(net_ip);
-  }
-
-  RTC_LOG_F(LS_INFO) << "(" << IPAddress(ip).ToSensitiveString() << ", "
-                     << error << ")";
-
-  if (error == 0) {
-    SocketAddress address(ip, dns_->port);
-    error = DoConnect(address);
-  } else {
-    Close();
-  }
-
-  if (error) {
-    error_ = error;
-    SignalCloseEvent(this, error_);
-  } else {
-    delete dns_;
-    dns_ = nullptr;
-  }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Win32SocketServer
-// Provides cricket base services on top of a win32 gui thread
-///////////////////////////////////////////////////////////////////////////////
-
-static UINT s_wm_wakeup_id = 0;
-const wchar_t Win32SocketServer::kWindowName[] = L"libjingle Message Window";
-
-Win32SocketServer::Win32SocketServer()
-    : wnd_(this), posted_(false), hdlg_(nullptr) {
-  if (s_wm_wakeup_id == 0)
-    s_wm_wakeup_id = RegisterWindowMessageW(L"WM_WAKEUP");
-  if (!wnd_.Create(nullptr, kWindowName, 0, 0, 0, 0, 0, 0)) {
-    RTC_LOG_GLE(LS_ERROR) << "Failed to create message window.";
-  }
-}
-
-Win32SocketServer::~Win32SocketServer() {
-  if (wnd_.handle() != nullptr) {
-    KillTimer(wnd_.handle(), 1);
-    wnd_.Destroy();
-  }
-}
-
-Socket* Win32SocketServer::CreateSocket(int family, int type) {
-  Win32Socket* socket = new Win32Socket;
-  if (socket->CreateT(family, type)) {
-    return socket;
-  }
-  delete socket;
-  return nullptr;
-}
-
-void Win32SocketServer::SetMessageQueue(Thread* queue) {
-  message_queue_ = queue;
-}
-
-bool Win32SocketServer::Wait(int cms, bool process_io) {
-  BOOL b;
-  if (process_io) {
-    // Spin the Win32 message pump at least once, and as long as requested.
-    // This is the Thread::ProcessMessages case.
-    uint32_t start = Time();
-    do {
-      MSG msg;
-      SetTimer(wnd_.handle(), 0, cms, nullptr);
-      // Get the next available message. If we have a modeless dialog, give
-      // give the message to IsDialogMessage, which will return true if it
-      // was a message for the dialog that it handled internally.
-      // Otherwise, dispatch as usual via Translate/DispatchMessage.
-      b = GetMessage(&msg, nullptr, 0, 0);
-      if (b == -1) {
-        RTC_LOG_GLE(LS_ERROR) << "GetMessage failed.";
-        return false;
-      } else if (b) {
-        if (!hdlg_ || !IsDialogMessage(hdlg_, &msg)) {
-          TranslateMessage(&msg);
-          DispatchMessage(&msg);
-        }
-      }
-      KillTimer(wnd_.handle(), 0);
-    } while (b && TimeSince(start) < cms);
-  } else if (cms != 0) {
-    // Sit and wait forever for a WakeUp. This is the Thread::Send case.
-    RTC_DCHECK(cms == -1);
-    MSG msg;
-    b = GetMessage(&msg, nullptr, s_wm_wakeup_id, s_wm_wakeup_id);
-    {
-      webrtc::MutexLock lock(&mutex_);
-      posted_ = false;
-    }
-  } else {
-    // No-op (cms == 0 && !process_io). This is the Pump case.
-    b = TRUE;
-  }
-  return (b != FALSE);
-}
-
-void Win32SocketServer::WakeUp() {
-  if (wnd_.handle()) {
-    // Set the "message pending" flag, if not already set.
-    {
-      webrtc::MutexLock lock(&mutex_);
-      if (posted_)
-        return;
-      posted_ = true;
-    }
-
-    PostMessage(wnd_.handle(), s_wm_wakeup_id, 0, 0);
-  }
-}
-
-void Win32SocketServer::Pump() {
-  // Clear the "message pending" flag.
-  {
-    webrtc::MutexLock lock(&mutex_);
-    posted_ = false;
-  }
-
-  // Dispatch all the messages that are currently in our queue. If new messages
-  // are posted during the dispatch, they will be handled in the next Pump.
-  // We use max(1, ...) to make sure we try to dispatch at least once, since
-  // this allow us to process "sent" messages, not included in the size() count.
-  Message msg;
-  for (size_t max_messages_to_process =
-           std::max<size_t>(1, message_queue_->size());
-       max_messages_to_process > 0 && message_queue_->Get(&msg, 0, false);
-       --max_messages_to_process) {
-    message_queue_->Dispatch(&msg);
-  }
-
-  // Anything remaining?
-  int delay = message_queue_->GetDelay();
-  if (delay == -1) {
-    KillTimer(wnd_.handle(), 1);
-  } else {
-    SetTimer(wnd_.handle(), 1, delay, nullptr);
-  }
-}
-
-bool Win32SocketServer::MessageWindow::OnMessage(UINT wm,
-                                                 WPARAM wp,
-                                                 LPARAM lp,
-                                                 LRESULT& lr) {
-  bool handled = false;
-  if (wm == s_wm_wakeup_id || (wm == WM_TIMER && wp == 1)) {
-    ss_->Pump();
-    lr = 0;
-    handled = true;
-  }
-  return handled;
-}
-
-Win32Thread::Win32Thread(SocketServer* ss) : Thread(ss), id_(0) {}
-
-Win32Thread::~Win32Thread() {
-  Stop();
-}
-
-void Win32Thread::Run() {
-  id_ = GetCurrentThreadId();
-  Thread::Run();
-  id_ = 0;
-}
-
-void Win32Thread::Quit() {
-  PostThreadMessage(id_, WM_QUIT, 0, 0);
-}
-
-}  // namespace rtc
diff --git a/rtc_base/win32_socket_server.h b/rtc_base/win32_socket_server.h
deleted file mode 100644
index 3e7d728..0000000
--- a/rtc_base/win32_socket_server.h
+++ /dev/null
@@ -1,151 +0,0 @@
-/*
- *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef RTC_BASE_WIN32_SOCKET_SERVER_H_
-#define RTC_BASE_WIN32_SOCKET_SERVER_H_
-
-#if defined(WEBRTC_WIN)
-#include "rtc_base/socket.h"
-#include "rtc_base/socket_factory.h"
-#include "rtc_base/socket_server.h"
-#include "rtc_base/synchronization/mutex.h"
-#include "rtc_base/thread.h"
-#include "rtc_base/win32_window.h"
-
-namespace rtc {
-
-///////////////////////////////////////////////////////////////////////////////
-// Win32Socket
-///////////////////////////////////////////////////////////////////////////////
-
-class Win32Socket : public Socket {
- public:
-  Win32Socket();
-  ~Win32Socket() override;
-
-  bool CreateT(int family, int type);
-
-  int Attach(SOCKET s);
-  void SetTimeout(int ms);
-
-  // Socket Interface
-  SocketAddress GetLocalAddress() const override;
-  SocketAddress GetRemoteAddress() const override;
-  int Bind(const SocketAddress& addr) override;
-  int Connect(const SocketAddress& addr) override;
-  int Send(const void* buffer, size_t length) override;
-  int SendTo(const void* buffer,
-             size_t length,
-             const SocketAddress& addr) override;
-  int Recv(void* buffer, size_t length, int64_t* timestamp) override;
-  int RecvFrom(void* buffer,
-               size_t length,
-               SocketAddress* out_addr,
-               int64_t* timestamp) override;
-  int Listen(int backlog) override;
-  Win32Socket* Accept(SocketAddress* out_addr) override;
-  int Close() override;
-  int GetError() const override;
-  void SetError(int error) override;
-  ConnState GetState() const override;
-  int GetOption(Option opt, int* value) override;
-  int SetOption(Option opt, int value) override;
-
- private:
-  void CreateSink();
-  bool SetAsync(int events);
-  int DoConnect(const SocketAddress& addr);
-  bool HandleClosed(int close_error);
-  void PostClosed();
-  void UpdateLastError();
-  static int TranslateOption(Option opt, int* slevel, int* sopt);
-
-  void OnSocketNotify(SOCKET socket, int event, int error);
-  void OnDnsNotify(HANDLE task, int error);
-
-  SOCKET socket_;
-  int error_;
-  ConnState state_;
-  SocketAddress addr_;  // address that we connected to (see DoConnect)
-  uint32_t connect_time_;
-  bool closing_;
-  int close_error_;
-
-  class EventSink;
-  friend class EventSink;
-  EventSink* sink_;
-
-  struct DnsLookup;
-  DnsLookup* dns_;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Win32SocketServer
-///////////////////////////////////////////////////////////////////////////////
-
-class Win32SocketServer : public SocketServer {
- public:
-  Win32SocketServer();
-  ~Win32SocketServer() override;
-
-  void set_modeless_dialog(HWND hdlg) { hdlg_ = hdlg; }
-
-  // SocketServer Interface
-  Socket* CreateSocket(int family, int type) override;
-
-  void SetMessageQueue(Thread* queue) override;
-  bool Wait(int cms, bool process_io) override;
-  void WakeUp() override;
-
-  void Pump();
-
-  HWND handle() { return wnd_.handle(); }
-
- private:
-  class MessageWindow : public Win32Window {
-   public:
-    explicit MessageWindow(Win32SocketServer* ss) : ss_(ss) {}
-
-   private:
-    bool OnMessage(UINT msg, WPARAM wp, LPARAM lp, LRESULT& result) override;
-    Win32SocketServer* ss_;
-  };
-
-  static const wchar_t kWindowName[];
-  Thread* message_queue_;
-  MessageWindow wnd_;
-  webrtc::Mutex mutex_;
-  bool posted_;
-  HWND hdlg_;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Win32Thread. Automatically pumps Windows messages.
-///////////////////////////////////////////////////////////////////////////////
-
-class Win32Thread : public Thread {
- public:
-  explicit Win32Thread(SocketServer* ss);
-  ~Win32Thread() override;
-
-  void Run() override;
-  void Quit() override;
-
- private:
-  DWORD id_;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-
-}  // namespace rtc
-
-#endif  // WEBRTC_WIN
-
-#endif  // RTC_BASE_WIN32_SOCKET_SERVER_H_
diff --git a/rtc_base/win32_socket_server_unittest.cc b/rtc_base/win32_socket_server_unittest.cc
deleted file mode 100644
index f75f513..0000000
--- a/rtc_base/win32_socket_server_unittest.cc
+++ /dev/null
@@ -1,162 +0,0 @@
-/*
- *  Copyright 2009 The WebRTC Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-#include "rtc_base/win32_socket_server.h"
-
-#include "rtc_base/gunit.h"
-#include "rtc_base/socket_unittest.h"
-#include "rtc_base/thread.h"
-
-namespace rtc {
-
-// Test that Win32SocketServer::Wait works as expected.
-TEST(Win32SocketServerTest, TestWait) {
-  Win32SocketServer server;
-  uint32_t start = Time();
-  server.Wait(1000, true);
-  EXPECT_GE(TimeSince(start), 1000);
-}
-
-// Test that Win32Socket::Pump does not touch general Windows messages.
-TEST(Win32SocketServerTest, TestPump) {
-  Win32SocketServer server;
-  rtc::AutoSocketServerThread thread(&server);
-  EXPECT_EQ(TRUE, PostMessage(nullptr, WM_USER, 999, 0));
-  server.Pump();
-  MSG msg;
-  EXPECT_EQ(TRUE, PeekMessage(&msg, nullptr, WM_USER, 0, PM_REMOVE));
-  EXPECT_EQ(static_cast<UINT>(WM_USER), msg.message);
-  EXPECT_EQ(999u, msg.wParam);
-}
-
-// Test that Win32Socket passes all the generic Socket tests.
-class Win32SocketTest : public SocketTest {
- protected:
-  Win32SocketTest() : SocketTest(&server_), thread_(&server_) {}
-  Win32SocketServer server_;
-  rtc::AutoSocketServerThread thread_;
-};
-
-TEST_F(Win32SocketTest, TestConnectIPv4) {
-  SocketTest::TestConnectIPv4();
-}
-
-TEST_F(Win32SocketTest, TestConnectIPv6) {
-  SocketTest::TestConnectIPv6();
-}
-
-TEST_F(Win32SocketTest, TestConnectWithDnsLookupIPv4) {
-  SocketTest::TestConnectWithDnsLookupIPv4();
-}
-
-TEST_F(Win32SocketTest, TestConnectWithDnsLookupIPv6) {
-  SocketTest::TestConnectWithDnsLookupIPv6();
-}
-
-TEST_F(Win32SocketTest, TestConnectFailIPv4) {
-  SocketTest::TestConnectFailIPv4();
-}
-
-TEST_F(Win32SocketTest, TestConnectFailIPv6) {
-  SocketTest::TestConnectFailIPv6();
-}
-
-TEST_F(Win32SocketTest, TestConnectWithDnsLookupFailIPv4) {
-  SocketTest::TestConnectWithDnsLookupFailIPv4();
-}
-
-TEST_F(Win32SocketTest, TestConnectWithDnsLookupFailIPv6) {
-  SocketTest::TestConnectWithDnsLookupFailIPv6();
-}
-
-TEST_F(Win32SocketTest, TestConnectWithClosedSocketIPv4) {
-  SocketTest::TestConnectWithClosedSocketIPv4();
-}
-
-TEST_F(Win32SocketTest, TestConnectWithClosedSocketIPv6) {
-  SocketTest::TestConnectWithClosedSocketIPv6();
-}
-
-TEST_F(Win32SocketTest, TestConnectWhileNotClosedIPv4) {
-  SocketTest::TestConnectWhileNotClosedIPv4();
-}
-
-TEST_F(Win32SocketTest, TestConnectWhileNotClosedIPv6) {
-  SocketTest::TestConnectWhileNotClosedIPv6();
-}
-
-TEST_F(Win32SocketTest, TestServerCloseDuringConnectIPv4) {
-  SocketTest::TestServerCloseDuringConnectIPv4();
-}
-
-TEST_F(Win32SocketTest, TestServerCloseDuringConnectIPv6) {
-  SocketTest::TestServerCloseDuringConnectIPv6();
-}
-
-TEST_F(Win32SocketTest, TestClientCloseDuringConnectIPv4) {
-  SocketTest::TestClientCloseDuringConnectIPv4();
-}
-
-TEST_F(Win32SocketTest, TestClientCloseDuringConnectIPv6) {
-  SocketTest::TestClientCloseDuringConnectIPv6();
-}
-
-TEST_F(Win32SocketTest, TestServerCloseIPv4) {
-  SocketTest::TestServerCloseIPv4();
-}
-
-TEST_F(Win32SocketTest, TestServerCloseIPv6) {
-  SocketTest::TestServerCloseIPv6();
-}
-
-TEST_F(Win32SocketTest, TestCloseInClosedCallbackIPv4) {
-  SocketTest::TestCloseInClosedCallbackIPv4();
-}
-
-TEST_F(Win32SocketTest, TestCloseInClosedCallbackIPv6) {
-  SocketTest::TestCloseInClosedCallbackIPv6();
-}
-
-TEST_F(Win32SocketTest, TestSocketServerWaitIPv4) {
-  SocketTest::TestSocketServerWaitIPv4();
-}
-
-TEST_F(Win32SocketTest, TestSocketServerWaitIPv6) {
-  SocketTest::TestSocketServerWaitIPv6();
-}
-
-TEST_F(Win32SocketTest, TestTcpIPv4) {
-  SocketTest::TestTcpIPv4();
-}
-
-TEST_F(Win32SocketTest, TestTcpIPv6) {
-  SocketTest::TestTcpIPv6();
-}
-
-TEST_F(Win32SocketTest, TestUdpIPv4) {
-  SocketTest::TestUdpIPv4();
-}
-
-TEST_F(Win32SocketTest, TestUdpIPv6) {
-  SocketTest::TestUdpIPv6();
-}
-
-// Breaks win_x64_dbg bot.
-// https://bugs.chromium.org/p/webrtc/issues/detail?id=6178
-TEST_F(Win32SocketTest, DISABLED_TestGetSetOptionsIPv4) {
-  SocketTest::TestGetSetOptionsIPv4();
-}
-
-// Breaks win_x64_dbg bot.
-// https://bugs.chromium.org/p/webrtc/issues/detail?id=6178
-TEST_F(Win32SocketTest, DISABLED_TestGetSetOptionsIPv6) {
-  SocketTest::TestGetSetOptionsIPv6();
-}
-
-}  // namespace rtc