react-native-windows 0.84.0 → 0.85.0-preview.1

package/Shared/Networking/WinRTWebSocketResource.cpp

@@ -24,8 +24,6 @@ using Microsoft::Common::Utilities::CheckedReinterpretCast;
 using Mso::DispatchQueue;
 
 using std::function;
-using std::lock_guard;
-using std::mutex;
 using std::string;
 using std::vector;
 
@@ -33,8 +31,6 @@ using winrt::fire_and_forget;
 using winrt::hresult;
 using winrt::hresult_error;
 using winrt::hstring;
-using winrt::resume_background;
-using winrt::resume_on_signal;
 using winrt::Windows::Foundation::IAsyncAction;
 using winrt::Windows::Foundation::Uri;
 using winrt::Windows::Networking::Sockets::IMessageWebSocket;
@@ -93,9 +89,9 @@ DispatchQueue GetCurrentOrSerialQueue() noexcept {
 
 namespace Microsoft::React::Networking {
 
-#pragma region WinRTWebSocketResource2
+#pragma region WinRTWebSocketResource
 
-WinRTWebSocketResource2::WinRTWebSocketResource2(
+WinRTWebSocketResource::WinRTWebSocketResource(
     IMessageWebSocket &&socket,
     IDataWriter &&writer,
     vector<ChainValidationResult> &&certExceptions,
@@ -110,22 +106,22 @@ WinRTWebSocketResource2::WinRTWebSocketResource2(
 }
 
 // private
-WinRTWebSocketResource2::WinRTWebSocketResource2(
+WinRTWebSocketResource::WinRTWebSocketResource(
     IMessageWebSocket &&socket,
     vector<ChainValidationResult> &&certExceptions)
-    : WinRTWebSocketResource2(
+    : WinRTWebSocketResource(
           std::move(socket),
           DataWriter{socket.OutputStream()},
           std::move(certExceptions),
           GetCurrentOrSerialQueue()) {}
 
-WinRTWebSocketResource2::WinRTWebSocketResource2(vector<ChainValidationResult> &&certExceptions)
-    : WinRTWebSocketResource2(MessageWebSocket{}, std::move(certExceptions)) {}
+WinRTWebSocketResource::WinRTWebSocketResource(vector<ChainValidationResult> &&certExceptions)
+    : WinRTWebSocketResource(MessageWebSocket{}, std::move(certExceptions)) {}
 
-WinRTWebSocketResource2::~WinRTWebSocketResource2() noexcept /*override*/
+WinRTWebSocketResource::~WinRTWebSocketResource() noexcept /*override*/
 {}
 
-void WinRTWebSocketResource2::Fail(string &&message, ErrorType type) noexcept {
+void WinRTWebSocketResource::Fail(string &&message, ErrorType type) noexcept {
   auto self = shared_from_this();
 
   self->m_backgroundQueue.Post([self, message = std::move(message), type]() {
@@ -138,15 +134,15 @@ void WinRTWebSocketResource2::Fail(string &&message, ErrorType type) noexcept {
   });
 }
 
-void WinRTWebSocketResource2::Fail(hresult &&error, ErrorType type) noexcept {
+void WinRTWebSocketResource::Fail(hresult &&error, ErrorType type) noexcept {
   Fail(Utilities::HResultToString(std::move(error)), type);
 }
 
-void WinRTWebSocketResource2::Fail(hresult_error const &error, ErrorType type) noexcept {
+void WinRTWebSocketResource::Fail(hresult_error const &error, ErrorType type) noexcept {
   Fail(Utilities::HResultToString(error), type);
 }
 
-void WinRTWebSocketResource2::OnMessageReceived(
+void WinRTWebSocketResource::OnMessageReceived(
     IMessageWebSocket const &,
     IMessageWebSocketMessageReceivedEventArgs const &args) {
   auto self = shared_from_this();
@@ -205,7 +201,7 @@ void WinRTWebSocketResource2::OnMessageReceived(
   });
 }
 
-void WinRTWebSocketResource2::OnClosed(IWebSocket const &sender, IWebSocketClosedEventArgs const &args) {
+void WinRTWebSocketResource::OnClosed(IWebSocket const &sender, IWebSocketClosedEventArgs const &args) {
   auto self = shared_from_this();
 
   self->m_backgroundQueue.Post([self]() { self->m_readyState = ReadyState::Closed; });
@@ -217,7 +213,7 @@ void WinRTWebSocketResource2::OnClosed(IWebSocket const &sender, IWebSocketClose
   });
 }
 
-fire_and_forget WinRTWebSocketResource2::PerformConnect(Uri &&uri) noexcept {
+fire_and_forget WinRTWebSocketResource::PerformConnect(Uri &&uri) noexcept {
   auto self = shared_from_this();
   auto movedUri = std::move(uri);
 
@@ -251,7 +247,7 @@ fire_and_forget WinRTWebSocketResource2::PerformConnect(Uri &&uri) noexcept {
       });
 }
 
-fire_and_forget WinRTWebSocketResource2::PerformClose() noexcept {
+fire_and_forget WinRTWebSocketResource::PerformClose() noexcept {
   auto self = shared_from_this();
 
   co_await resume_in_queue(self->m_backgroundQueue);
@@ -274,7 +270,7 @@ fire_and_forget WinRTWebSocketResource2::PerformClose() noexcept {
   });
 }
 
-fire_and_forget WinRTWebSocketResource2::EnqueueWrite(string &&message, bool isBinary) noexcept {
+fire_and_forget WinRTWebSocketResource::EnqueueWrite(string &&message, bool isBinary) noexcept {
   auto self = shared_from_this();
   string coMessage = std::move(message);
 
@@ -289,7 +285,7 @@ fire_and_forget WinRTWebSocketResource2::EnqueueWrite(string &&message, bool isB
       });
 }
 
-IAsyncAction WinRTWebSocketResource2::PerformWrite(string &&message, bool isBinary) noexcept {
+IAsyncAction WinRTWebSocketResource::PerformWrite(string &&message, bool isBinary) noexcept {
   auto self = shared_from_this();
 
   try {
@@ -331,7 +327,7 @@ IAsyncAction WinRTWebSocketResource2::PerformWrite(string &&message, bool isBina
 
 #pragma region IWebSocketResource
 
-void WinRTWebSocketResource2::Connect(string &&url, const Protocols &protocols, const Options &options) noexcept {
+void WinRTWebSocketResource::Connect(string &&url, const Protocols &protocols, const Options &options) noexcept {
   // Register MessageReceived BEFORE calling Connect
   // https://learn.microsoft.com/en-us/uwp/api/windows.networking.sockets.messagewebsocket.messagereceived?view=winrt-22621
   m_socket.MessageReceived([self = shared_from_this()](
@@ -385,394 +381,17 @@ void WinRTWebSocketResource2::Connect(string &&url, const Protocols &protocols,
   PerformConnect(std::move(uri));
 }
 
-void WinRTWebSocketResource2::Ping() noexcept {}
-
-void WinRTWebSocketResource2::Send(string &&message) noexcept {
-  EnqueueWrite(std::move(message), false);
-}
-
-void WinRTWebSocketResource2::SendBinary(string &&base64String) noexcept {
-  EnqueueWrite(std::move(base64String), true);
-}
-
-void WinRTWebSocketResource2::Close(CloseCode code, const string &reason) noexcept {
-  m_closeCode = code;
-  m_closeReason = reason;
-  PerformClose();
-}
-
-IWebSocketResource::ReadyState WinRTWebSocketResource2::GetReadyState() const noexcept {
-  return m_readyState;
-}
-
-void WinRTWebSocketResource2::SetOnConnect(function<void()> &&handler) noexcept {
-  m_connectHandler = std::move(handler);
-}
-
-void WinRTWebSocketResource2::SetOnPing(function<void()> && /*handler*/) noexcept {}
-
-void WinRTWebSocketResource2::SetOnSend(function<void(size_t)> && /*handler*/) noexcept {}
-
-void WinRTWebSocketResource2::SetOnMessage(function<void(size_t, const string &, bool isBinary)> &&handler) noexcept {
-  m_readHandler = std::move(handler);
-}
-
-void WinRTWebSocketResource2::SetOnClose(function<void(CloseCode, const string &)> &&handler) noexcept {
-  m_closeHandler = std::move(handler);
-}
-
-void WinRTWebSocketResource2::SetOnError(function<void(Error &&)> &&handler) noexcept {
-  m_errorHandler = std::move(handler);
-}
-
-#pragma endregion IWebSocketResource
-
-#pragma endregion WinRTWebSocketResource2
-
-#pragma region Legacy resource
-// private
-WinRTWebSocketResource::WinRTWebSocketResource(
-    IMessageWebSocket &&socket,
-    vector<ChainValidationResult> &&certExceptions)
-    : WinRTWebSocketResource(std::move(socket), DataWriter{socket.OutputStream()}, std::move(certExceptions)) {}
-
-WinRTWebSocketResource::WinRTWebSocketResource(
-    IMessageWebSocket &&socket,
-    IDataWriter &&writer,
-    vector<ChainValidationResult> &&certExceptions)
-    : m_socket{std::move(socket)}, m_writer{std::move(writer)} {
-  for (const auto &certException : certExceptions) {
-    m_socket.Control().IgnorableServerCertificateErrors().Append(certException);
-  }
-}
-
-WinRTWebSocketResource::WinRTWebSocketResource(vector<ChainValidationResult> &&certExceptions)
-    : WinRTWebSocketResource(MessageWebSocket{}, std::move(certExceptions)) {}
-
-WinRTWebSocketResource::~WinRTWebSocketResource() noexcept /*override*/
-{
-  Close(CloseCode::GoingAway, "Disposed");
-
-  m_closePerformed.Wait();
-}
-
-#pragma region Private members
-
-IAsyncAction WinRTWebSocketResource::PerformConnect(Uri &&uri) noexcept {
-  auto self = shared_from_this();
-  auto coUri = std::move(uri);
-
-  co_await resume_background();
-
-  try {
-    auto async = self->m_socket.ConnectAsync(coUri);
-
-    co_await lessthrow_await_adapter<IAsyncAction>{async};
-
-    auto result = async.ErrorCode();
-    if (result >= 0) {
-      self->m_readyState = ReadyState::Open;
-      if (self->m_connectHandler) {
-        self->m_connectHandler();
-      }
-    } else {
-      if (self->m_errorHandler) {
-        self->m_errorHandler({Utilities::HResultToString(std::move(result)), ErrorType::Connection});
-      }
-    }
-  } catch (hresult_error const &e) {
-    if (self->m_errorHandler) {
-      self->m_errorHandler({Utilities::HResultToString(e), ErrorType::Connection});
-    }
-  }
-
-  SetEvent(self->m_connectPerformed.get());
-  self->m_connectPerformedPromise.set_value();
-  self->m_connectRequested = false;
-}
-
-fire_and_forget WinRTWebSocketResource::PerformPing() noexcept {
-  auto self = shared_from_this();
-
-  co_await resume_background();
-
-  co_await resume_on_signal(self->m_connectPerformed.get());
-
-  if (self->m_readyState != ReadyState::Open) {
-    self = nullptr;
-    co_return;
-  }
-
-  try {
-    self->m_socket.Control().MessageType(SocketMessageType::Utf8);
-
-    string s{};
-    winrt::array_view<const uint8_t> arr(
-        CheckedReinterpretCast<const uint8_t *>(s.c_str()),
-        CheckedReinterpretCast<const uint8_t *>(s.c_str()) + s.length());
-    self->m_writer.WriteBytes(arr);
-
-    auto async = self->m_writer.StoreAsync();
-
-    co_await lessthrow_await_adapter<DataWriterStoreOperation>{async};
-
-    auto result = async.ErrorCode();
-    if (result >= 0) {
-      if (self->m_pingHandler) {
-        self->m_pingHandler();
-      }
-    } else {
-      if (self->m_errorHandler) {
-        self->m_errorHandler({Utilities::HResultToString(std::move(result)), ErrorType::Ping});
-      }
-    }
-  } catch (hresult_error const &e) {
-    if (self->m_errorHandler) {
-      self->m_errorHandler({Utilities::HResultToString(e), ErrorType::Ping});
-    }
-  }
-}
-
-fire_and_forget WinRTWebSocketResource::PerformWrite(string &&message, bool isBinary) noexcept {
-  auto self = shared_from_this();
-  {
-    auto guard = lock_guard<mutex>{m_writeQueueMutex};
-    m_writeQueue.emplace(std::move(message), isBinary);
-  }
-
-  co_await resume_background();
-
-  co_await resume_on_signal(self->m_connectPerformed.get()); // Ensure connection attempt has finished
-
-  co_await resume_in_queue(self->m_dispatchQueue); // Ensure writes happen sequentially
-
-  if (self->m_readyState != ReadyState::Open) {
-    self = nullptr;
-    co_return;
-  }
-
-  try {
-    size_t length = 0;
-    string messageLocal;
-    bool isBinaryLocal;
-    {
-      auto guard = lock_guard<mutex>{m_writeQueueMutex};
-      std::tie(messageLocal, isBinaryLocal) = m_writeQueue.front();
-      m_writeQueue.pop();
-    }
-
-    if (isBinaryLocal) {
-      self->m_socket.Control().MessageType(SocketMessageType::Binary);
-
-      auto buffer = CryptographicBuffer::DecodeFromBase64String(winrt::to_hstring(messageLocal));
-      if (buffer) {
-        length = buffer.Length();
-        self->m_writer.WriteBuffer(buffer);
-      }
-    } else {
-      self->m_socket.Control().MessageType(SocketMessageType::Utf8);
-
-      // TODO: Use char_t instead of uint8_t?
-      length = messageLocal.size();
-      winrt::array_view<const uint8_t> view(
-          CheckedReinterpretCast<const uint8_t *>(messageLocal.c_str()),
-          CheckedReinterpretCast<const uint8_t *>(messageLocal.c_str()) + messageLocal.length());
-      self->m_writer.WriteBytes(view);
-    }
-
-    auto async = self->m_writer.StoreAsync();
-
-    co_await lessthrow_await_adapter<DataWriterStoreOperation>{async};
-
-    auto result = async.ErrorCode();
-    if (result >= 0) {
-      if (self->m_writeHandler) {
-        self->m_writeHandler(length);
-      }
-    } else {
-      if (self->m_errorHandler) {
-        self->m_errorHandler({Utilities::HResultToString(std::move(result)), ErrorType::Send});
-      }
-    }
-  } catch (std::exception const &e) {
-    if (self->m_errorHandler) {
-      self->m_errorHandler({e.what(), ErrorType::Ping});
-    }
-  } catch (hresult_error const &e) {
-    // TODO: Remove after fixing unit tests exceptions.
-    if (self->m_errorHandler) {
-      self->m_errorHandler({Utilities::HResultToString(e), ErrorType::Ping});
-    }
-  }
-}
-
-fire_and_forget WinRTWebSocketResource::PerformClose() noexcept {
-  co_await resume_background();
-
-  co_await resume_on_signal(m_connectPerformed.get());
-
-  try {
-    m_socket.Close(static_cast<uint16_t>(m_closeCode), winrt::to_hstring(m_closeReason));
-
-    if (m_closeHandler) {
-      m_closeHandler(m_closeCode, m_closeReason);
-    }
-  } catch (winrt::hresult_invalid_argument const &e) {
-    if (m_errorHandler) {
-      m_errorHandler({winrt::to_string(e.message()), ErrorType::Close});
-    }
-  } catch (hresult_error const &e) {
-    if (m_errorHandler) {
-      m_errorHandler({Utilities::HResultToString(e), ErrorType::Close});
-    }
-  }
-
-  m_readyState = ReadyState::Closed;
-  m_closePerformed.Set();
-}
-
-void WinRTWebSocketResource::Synchronize() noexcept {
-  // Ensure sequence of other operations
-  if (m_connectRequested) {
-    m_connectPerformedPromise.get_future().wait();
-  }
-}
-
-#pragma endregion Private members
-
-#pragma region IWebSocketResource
-
-void WinRTWebSocketResource::Connect(string &&url, const Protocols &protocols, const Options &options) noexcept {
-  m_socket.MessageReceived([self = shared_from_this()](
-                               IWebSocket const &sender, IMessageWebSocketMessageReceivedEventArgs const &args) {
-    try {
-      string response;
-
-      IDataReader reader{nullptr};
-      // Use ABI version to avoid throwing exceptions on expected code paths
-      HRESULT hr =
-          reinterpret_cast<ABI::Windows::Networking::Sockets::IMessageWebSocketMessageReceivedEventArgs *>(
-              winrt::get_abi(args))
-              ->GetDataReader(reinterpret_cast<ABI::Windows::Storage::Streams::IDataReader **>(winrt::put_abi(reader)));
-
-      if (FAILED(hr)) {
-        // See
-        // https://docs.microsoft.com/uwp/api/windows.networking.sockets.messagewebsocketmessagereceivedeventargs.getdatareader?view=winrt-22621#remarks
-        if (hr == WININET_E_CONNECTION_ABORTED) {
-          string errorMessage{"[0x80072EFE] Underlying TCP connection suddenly terminated"};
-          self->m_errorHandler({errorMessage, ErrorType::Connection});
-          // Note: We are not clear whether all read-related errors should close the socket.
-          self->Close(CloseCode::BadPayload, std::move(errorMessage));
-        } else {
-          self->m_errorHandler({Utilities::HResultToString(hr), ErrorType::Receive});
-        }
-        return;
-      }
-
-      auto len = reader.UnconsumedBufferLength();
-      if (args.MessageType() == SocketMessageType::Utf8) {
-        reader.UnicodeEncoding(UnicodeEncoding::Utf8);
-        vector<uint8_t> data(len);
-        reader.ReadBytes(data);
-
-        response = string(CheckedReinterpretCast<char *>(data.data()), data.size());
-      } else {
-        auto buffer = reader.ReadBuffer(len);
-        hstring data = CryptographicBuffer::EncodeToBase64String(buffer);
-
-        response = winrt::to_string(std::wstring_view(data));
-      }
-
-      if (self->m_readHandler) {
-        self->m_readHandler(response.length(), response, args.MessageType() == SocketMessageType::Binary);
-      }
-    } catch (hresult_error const &e) {
-      if (self->m_errorHandler) {
-        string errorMessage;
-        ErrorType errorType;
-        errorMessage = Utilities::HResultToString(e);
-        errorType = ErrorType::Receive;
-        self->m_errorHandler({errorMessage, errorType});
-      }
-    }
-  });
-
-  m_readyState = ReadyState::Connecting;
-
-  bool hasOriginHeader = false;
-  for (const auto &header : options) {
-    m_socket.SetRequestHeader(header.first, winrt::to_hstring(header.second));
-    if (boost::iequals(header.first, L"Origin")) {
-      hasOriginHeader = true;
-    }
-  }
-
-  winrt::Windows::Foundation::Collections::IVector<hstring> supportedProtocols =
-      m_socket.Control().SupportedProtocols();
-  for (const auto &protocol : protocols) {
-    supportedProtocols.Append(winrt::to_hstring(protocol));
-  }
-
-  Uri uri{nullptr};
-  try {
-    uri = Uri{winrt::to_hstring(url)};
-
-    // #12626 - If Origin header is not provided, set to connect endpoint.
-    if (!hasOriginHeader) {
-      auto scheme = uri.SchemeName();
-      auto host = uri.Host();
-      auto port = uri.Port();
-
-      if (scheme == L"ws") {
-        scheme = L"http";
-      } else if (scheme == L"wss") {
-        scheme = L"https";
-      }
-
-      // Only add a port if a port is defined
-      hstring originPort = port != 0 ? L":" + winrt::to_hstring(port) : L"";
-      auto origin = hstring{scheme + L"://" + host + originPort};
-
-      m_socket.SetRequestHeader(L"Origin", std::move(origin));
-    }
-
-  } catch (hresult_error const &e) {
-    if (m_errorHandler) {
-      m_errorHandler({Utilities::HResultToString(e), ErrorType::Connection});
-    }
-
-    // Abort - Mark connection as concluded.
-    SetEvent(m_connectPerformed.get());
-    m_connectPerformedPromise.set_value();
-    m_connectRequested = false;
-
-    return;
-  }
-
-  m_connectRequested = true;
-
-  PerformConnect(std::move(uri));
-}
-
-void WinRTWebSocketResource::Ping() noexcept {
-  PerformPing();
-}
+void WinRTWebSocketResource::Ping() noexcept {}
 
 void WinRTWebSocketResource::Send(string &&message) noexcept {
-  PerformWrite(std::move(message), false);
+  EnqueueWrite(std::move(message), false);
 }
 
 void WinRTWebSocketResource::SendBinary(string &&base64String) noexcept {
-  PerformWrite(std::move(base64String), true);
+  EnqueueWrite(std::move(base64String), true);
 }
 
 void WinRTWebSocketResource::Close(CloseCode code, const string &reason) noexcept {
-  if (m_readyState == ReadyState::Closing || m_readyState == ReadyState::Closed)
-    return;
-
-  Synchronize();
-
-  m_readyState = ReadyState::Closing;
   m_closeCode = code;
   m_closeReason = reason;
   PerformClose();
@@ -786,13 +405,9 @@ void WinRTWebSocketResource::SetOnConnect(function<void()> &&handler) noexcept {
   m_connectHandler = std::move(handler);
 }
 
-void WinRTWebSocketResource::SetOnPing(function<void()> &&handler) noexcept {
-  m_pingHandler = std::move(handler);
-}
+void WinRTWebSocketResource::SetOnPing(function<void()> && /*handler*/) noexcept {}
 
-void WinRTWebSocketResource::SetOnSend(function<void(size_t)> &&handler) noexcept {
-  m_writeHandler = std::move(handler);
-}
+void WinRTWebSocketResource::SetOnSend(function<void(size_t)> && /*handler*/) noexcept {}
 
 void WinRTWebSocketResource::SetOnMessage(function<void(size_t, const string &, bool isBinary)> &&handler) noexcept {
   m_readHandler = std::move(handler);
@@ -808,6 +423,6 @@ void WinRTWebSocketResource::SetOnError(function<void(Error &&)> &&handler) noex
 
 #pragma endregion IWebSocketResource
 
-#pragma endregion Legacy resource
+#pragma endregion WinRTWebSocketResource
 
 } // namespace Microsoft::React::Networking

package/Shared/Networking/WinRTWebSocketResource.h

@@ -9,15 +9,9 @@
 #include <winrt/Windows.Storage.Streams.h>
 #include "IWebSocketResource.h"
 
-// Standard Library
-#include <future>
-#include <mutex>
-#include <queue>
-
 namespace Microsoft::React::Networking {
 
-class WinRTWebSocketResource2 : public IWebSocketResource,
-                                public std::enable_shared_from_this<WinRTWebSocketResource2> {
+class WinRTWebSocketResource : public IWebSocketResource, public std::enable_shared_from_this<WinRTWebSocketResource> {
   ///
   // See https://devblogs.microsoft.com/oldnewthing/20250328-00/?p=111016
   ///
@@ -144,126 +138,16 @@ class WinRTWebSocketResource2 : public IWebSocketResource,
   winrt::Windows::Foundation::IAsyncAction PerformWrite(std::string &&message, bool isBinary) noexcept;
   winrt::fire_and_forget PerformClose() noexcept;
 
-  WinRTWebSocketResource2(
-      winrt::Windows::Networking::Sockets::IMessageWebSocket &&socket,
-      std::vector<winrt::Windows::Security::Cryptography::Certificates::ChainValidationResult> &&certExceptions);
-
- public:
-  WinRTWebSocketResource2(
-      winrt::Windows::Networking::Sockets::IMessageWebSocket &&socket,
-      winrt::Windows::Storage::Streams::IDataWriter &&writer,
-      std::vector<winrt::Windows::Security::Cryptography::Certificates::ChainValidationResult> &&certExceptions,
-      Mso::DispatchQueue callingQueue);
-
-  WinRTWebSocketResource2(
-      std::vector<winrt::Windows::Security::Cryptography::Certificates::ChainValidationResult> &&certExceptions);
-
-  ~WinRTWebSocketResource2() noexcept override;
-
-#pragma region IWebSocketResource
-
-  /// <summary>
-  /// <see cref="IWebSocketResource::Connect" />
-  /// </summary>
-  void Connect(std::string &&url, const Protocols &protocols, const Options &options) noexcept override;
-
-  /// <summary>
-  /// <see cref="IWebSocketResource::Ping" />
-  /// </summary>
-  void Ping() noexcept override;
-
-  /// <summary>
-  /// <see cref="IWebSocketResource::Send" />
-  /// </summary>
-  void Send(std::string &&message) noexcept override;
-
-  /// <summary>
-  /// <see cref="IWebSocketResource::SendBinary" />
-  /// </summary>
-  void SendBinary(std::string &&base64String) noexcept override;
-
-  /// <summary>
-  /// <see cref="IWebSocketResource::Close" />
-  /// </summary>
-  void Close(CloseCode code, const std::string &reason) noexcept override;
-
-  ReadyState GetReadyState() const noexcept override;
-
-  /// <summary>
-  /// <see cref="IWebSocketResource::SetOnConnect" />
-  /// </summary>
-  void SetOnConnect(std::function<void()> &&handler) noexcept override;
-
-  /// <summary>
-  /// <see cref="IWebSocketResource::SetOnPing" />
-  /// </summary>
-  void SetOnPing(std::function<void()> &&handler) noexcept override;
-
-  /// <summary>
-  /// <see cref="IWebSocketResource::SetOnSend" />
-  /// </summary>
-  void SetOnSend(std::function<void(std::size_t)> &&handler) noexcept override;
-
-  /// <summary>
-  /// <see cref="IWebSocketResource::SetOnMessage" />
-  /// </summary>
-  void SetOnMessage(std::function<void(std::size_t, const std::string &, bool isBinary)> &&handler) noexcept override;
-
-  /// <summary>
-  /// <see cref="IWebSocketResource::SetOnClose" />
-  /// </summary>
-  void SetOnClose(std::function<void(CloseCode, const std::string &)> &&handler) noexcept override;
-
-  /// <summary>
-  /// <see cref="IWebSocketResource::SetOnError" />
-  /// </summary>
-  void SetOnError(std::function<void(Error &&)> &&handler) noexcept override;
-
-#pragma endregion IWebSocketResource
-};
-
-class WinRTWebSocketResource : public IWebSocketResource, public std::enable_shared_from_this<WinRTWebSocketResource> {
-  winrt::Windows::Networking::Sockets::IMessageWebSocket m_socket;
-  // TODO: Use or remove.
-  winrt::Windows::Networking::Sockets::IMessageWebSocket::MessageReceived_revoker m_revoker;
-  winrt::Windows::Storage::Streams::IDataWriter m_writer;
-
-  Mso::DispatchQueue m_dispatchQueue;
-  Mso::ManualResetEvent m_closePerformed;
-  std::atomic_bool m_connectRequested;
-  std::promise<void> m_connectPerformedPromise;
-  winrt::handle m_connectPerformed{
-      CreateEvent(/*attributes*/ nullptr, /*manual reset*/ true, /*state*/ false, /*name*/ nullptr)};
-  ReadyState m_readyState{ReadyState::Connecting};
-
-  CloseCode m_closeCode{CloseCode::Normal};
-  std::string m_closeReason;
-  std::queue<std::pair<std::string, bool>> m_writeQueue;
-  std::mutex m_writeQueueMutex;
-
-  std::function<void()> m_connectHandler;
-  std::function<void()> m_pingHandler;
-  std::function<void(std::size_t)> m_writeHandler;
-  std::function<void(std::size_t, const std::string &, bool)> m_readHandler;
-  std::function<void(CloseCode, const std::string &)> m_closeHandler;
-  std::function<void(Error &&)> m_errorHandler;
-
   WinRTWebSocketResource(
       winrt::Windows::Networking::Sockets::IMessageWebSocket &&socket,
       std::vector<winrt::Windows::Security::Cryptography::Certificates::ChainValidationResult> &&certExceptions);
 
-  winrt::Windows::Foundation::IAsyncAction PerformConnect(winrt::Windows::Foundation::Uri &&uri) noexcept;
-  winrt::fire_and_forget PerformPing() noexcept;
-  winrt::fire_and_forget PerformWrite(std::string &&message, bool isBinary) noexcept;
-  winrt::fire_and_forget PerformClose() noexcept;
-
-  void Synchronize() noexcept;
-
  public:
   WinRTWebSocketResource(
       winrt::Windows::Networking::Sockets::IMessageWebSocket &&socket,
       winrt::Windows::Storage::Streams::IDataWriter &&writer,
-      std::vector<winrt::Windows::Security::Cryptography::Certificates::ChainValidationResult> &&certExceptions);
+      std::vector<winrt::Windows::Security::Cryptography::Certificates::ChainValidationResult> &&certExceptions,
+      Mso::DispatchQueue callingQueue);
 
   WinRTWebSocketResource(
       std::vector<winrt::Windows::Security::Cryptography::Certificates::ChainValidationResult> &&certExceptions);